{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "57e00756",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense\n",
    "from keras.layers import LSTM,Dropout\n",
    "import pandas as pd\n",
    "import os\n",
    "from keras.models import Sequential, load_model\n",
    "import tensorflow as tf\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import rcParams\n",
    "config = {\n",
    "    \"font.family\":'Times New Roman',  # 设置字体类型\n",
    "    \"font.size\": 12,\n",
    "#     \"mathtext.fontset\":'stix',\n",
    "}# plt.rcParams['font.sans-serif'] = ['SimHei']\n",
    "# plt.rcParams['axes.unicode_minus'] = False\n",
    "from sklearn.metrics import r2_score\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9ae5ce35",
   "metadata": {},
   "outputs": [],
   "source": [
    "from statsmodels.tsa.seasonal import seasonal_decompose\n",
    "from statsmodels.tsa.stattools import adfuller\n",
    "import statsmodels.api as sm\n",
    "from statsmodels.tsa.statespace.sarimax import SARIMAX\n",
    "from statsmodels.tsa.stattools import acf,pacf\n",
    "from statsmodels.graphics.tsaplots import plot_acf, plot_pacf\n",
    "from statsmodels.stats.diagnostic import acorr_ljungbox"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "20efb4c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv(\"数据(1).csv\",encoding = 'gb2312').iloc[:,:4]\n",
    "data['time'] = pd.to_datetime(data['time'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5a52aad7",
   "metadata": {},
   "outputs": [],
   "source": [
    "newcar = data[['新能源汽车销量','time']]\n",
    "elecar = data[['纯电动汽车销量','time']]\n",
    "blendcar = data[['插电混动汽车销量','time']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "8cbaa55c",
   "metadata": {},
   "outputs": [],
   "source": [
    "newcar_model = load_model(\"models/models/newcar_bp_lstm.h5\")\n",
    "elecar_model = load_model(\"models/models/elecar_bp_lstm.h5\")\n",
    "blendcar_model = load_model(\"models/models/blendcar_bp_lstm.h5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "3135f2ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cal_mse_and_rmse(mte_truth, mte_forecast):\n",
    "    mse = ((mte_forecast - mte_truth) ** 2).mean()\n",
    "    mse = round(mse, 2)\n",
    "    rmse = np.sqrt(sum((mte_forecast-mte_truth)**2)/len(mte_forecast))\n",
    "    rmse = round(rmse, 4)\n",
    "    mape = np.mean(np.abs((mte_truth - mte_forecast) / mte_truth)) * 100\n",
    "    r2 = r2_score(mte_truth, mte_forecast)\n",
    "    print(f'预测值的均方误差(MSE)是{mse}')\n",
    "    print(f'预测值的均方根误差(RMSE)是{rmse}')\n",
    "    print(f'预测值的平均绝对百分比误差(MAPE)是{mape}')\n",
    "    print(f'预测值的R2是{r2}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "af68eb76",
   "metadata": {},
   "outputs": [],
   "source": [
    "def data_process(result, maxlen):\n",
    "    result = result.astype('float32')\n",
    "    newcar_list = result[:maxlen]\n",
    "    elecarlist = result[maxlen:maxlen*2]\n",
    "    blendcar_list = result[maxlen*2:maxlen*3]\n",
    "    return newcar_list,elecarlist, blendcar_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b08a00b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "all_result = np.append(np.append(newcar['新能源汽车销量'], elecar['纯电动汽车销量']),blendcar['插电混动汽车销量'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "098ca552",
   "metadata": {},
   "outputs": [],
   "source": [
    "scaler = MinMaxScaler(feature_range=(0, 1))\n",
    "result = scaler.fit_transform(all_result.reshape(-1,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "4778941a",
   "metadata": {},
   "outputs": [],
   "source": [
    "newcar_list,elecar_list, blendcar_list = data_process(result, blendcar.shape[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "2358ce85",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cal_mse_and_rmse(mte_truth, mte_forecast):\n",
    "    mse = ((mte_forecast - mte_truth) ** 2).mean()\n",
    "    mse = round(mse, 2)\n",
    "    rmse = np.sqrt(sum((mte_forecast-mte_truth)**2)/len(mte_forecast))\n",
    "    rmse = round(rmse, 4)\n",
    "    mape = np.mean(np.abs((mte_truth - mte_forecast) / mte_truth)) * 100\n",
    "    r2 = r2_score(mte_truth, mte_forecast)\n",
    "    print(f'预测值的均方误差(MSE)是{mse}')\n",
    "    print(f'预测值的均方根误差(RMSE)是{rmse}')\n",
    "    print(f'预测值的平均绝对百分比误差(MAPE)是{mape}')\n",
    "    print(f'预测值的R2是{r2}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "4517173f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_dataset(dataset, look_back):\n",
    "#这里的look_back与timestep相同\n",
    "    dataX, dataY = [], []\n",
    "    for i in range(len(dataset)-look_back-1):\n",
    "        a = dataset[i:(i+look_back)]\n",
    "        dataX.append(a)\n",
    "        dataY.append(dataset[i + look_back])\n",
    "    return np.array(dataX),np.array(dataY)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "05dee6d1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict_next(model, sample, epoch=14):\n",
    "    temp1 = list(sample[:,0])\n",
    "    for i in range(epoch):\n",
    "        sample = sample.reshape(1, 1, 1)\n",
    "        pred = model.predict(sample)\n",
    "        value = pred.tolist()[0][0]\n",
    "        temp1.append(value)\n",
    "        sample = np.array(temp1[i+1 : i+1+1])\n",
    "    return temp1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "99a1851b",
   "metadata": {},
   "outputs": [],
   "source": [
    "look_back =1\n",
    "newcar_trainX,newcar_trainY  = create_dataset(newcar_list,look_back)\n",
    "elecar_trainX,elecar_trainY  = create_dataset(elecar_list,look_back)\n",
    "blendcar_trainX,blendcar_trainY  = create_dataset(blendcar_list,look_back)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "1172bec5",
   "metadata": {},
   "outputs": [],
   "source": [
    "newcar_preds = predict_next(newcar_model, np.expand_dims(newcar_list[-1],axis=0), 18)\n",
    "elecar_preds = predict_next(elecar_model, np.expand_dims(elecar_list[-1],axis=0), 18)\n",
    "blendcar_preds = predict_next(blendcar_model, np.expand_dims(blendcar_list[-1],axis=0), 18)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "5028bfc9",
   "metadata": {},
   "outputs": [],
   "source": [
    "newcar_data1 = scaler.inverse_transform(np.array(newcar_preds).reshape(-1,1)) \n",
    "elecar_data1 = scaler.inverse_transform(np.array(elecar_preds).reshape(-1,1)) \n",
    "blendcar_data1 = scaler.inverse_transform(np.array(blendcar_preds).reshape(-1,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b42b054f",
   "metadata": {},
   "outputs": [],
   "source": [
    "datarange = list(pd.date_range(start=\"2022-06-01\",end=\"2023-12-01\",freq='MS'))\n",
    "date_list = [ x.strftime('%F') for x in datarange]\n",
    "\n",
    "newcar_preds = pd.DataFrame({'pred':newcar_data1.reshape(19)},index=date_list)\n",
    "elecar_preds = pd.DataFrame({'pred':elecar_data1.reshape(19)},index=date_list)\n",
    "blendcar_preds = pd.DataFrame({'pred':blendcar_data1.reshape(19)},index=date_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "9f1864b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "newcar_trainPredict = newcar_model.predict(newcar_trainX)\n",
    "elecar_trainPredict = elecar_model.predict(elecar_trainX)\n",
    "blendcar_trainPredict = blendcar_model.predict(blendcar_trainX)\n",
    "\n",
    "#反归一化\n",
    "newcar_trainPredict = scaler.inverse_transform(newcar_trainPredict)\n",
    "newcar_trainY = scaler.inverse_transform(newcar_trainY)\n",
    "\n",
    "elecar_trainPredict = scaler.inverse_transform(elecar_trainPredict)\n",
    "elecar_trainY = scaler.inverse_transform(elecar_trainY)\n",
    "\n",
    "blendcar_trainPredict = scaler.inverse_transform(blendcar_trainPredict)\n",
    "blendcar_trainY = scaler.inverse_transform(blendcar_trainY)\n",
    "\n",
    "newcarPred = newcar_trainPredict.flatten()[:67]\n",
    "elecarPred = elecar_trainPredict.flatten()[:67]\n",
    "blendcarPred = blendcar_trainPredict.flatten()[:67]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "ccd371e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==============================================================================\n",
      "                 coef    std err          z      P>|z|      [0.025      0.975]\n",
      "------------------------------------------------------------------------------\n",
      "ma.L1         -0.2671      0.099     -2.686      0.007      -0.462      -0.072\n",
      "ma.S.L12      -0.2359      0.298     -0.790      0.429      -0.821       0.349\n",
      "sigma2       1.82e+09   1.45e-10   1.25e+19      0.000    1.82e+09    1.82e+09\n",
      "==============================================================================\n",
      "/n\n",
      "==============================================================================\n",
      "                 coef    std err          z      P>|z|      [0.025      0.975]\n",
      "------------------------------------------------------------------------------\n",
      "ma.L1         -0.3183      0.131     -2.427      0.015      -0.575      -0.061\n",
      "ma.S.L12      -0.3523      0.330     -1.068      0.286      -0.999       0.294\n",
      "sigma2      1.537e+09   1.05e-10   1.47e+19      0.000    1.54e+09    1.54e+09\n",
      "==============================================================================\n",
      "/n\n",
      "==============================================================================\n",
      "                 coef    std err          z      P>|z|      [0.025      0.975]\n",
      "------------------------------------------------------------------------------\n",
      "ma.L1         -0.0282      0.144     -0.196      0.844      -0.310       0.254\n",
      "ma.S.L12      -0.7747      0.145     -5.344      0.000      -1.059      -0.491\n",
      "sigma2      1.466e+08   2.99e-10    4.9e+17      0.000    1.47e+08    1.47e+08\n",
      "==============================================================================\n"
     ]
    }
   ],
   "source": [
    "newcar_mod = sm.tsa.statespace.SARIMAX(newcar['新能源汽车销量'], \n",
    "                                order=(0,1,1), \n",
    "                                seasonal_order=(0,1,1,12),   \n",
    "                                enforce_stationarity=False,\n",
    "                                enforce_invertibility=False)\n",
    "results1 = newcar_mod.fit()\n",
    "print(results1.summary().tables[1])\n",
    "print(\"/n\")\n",
    "\n",
    "elecar_mod = sm.tsa.statespace.SARIMAX(elecar['纯电动汽车销量'], \n",
    "                                order=(0,1,1), \n",
    "                                seasonal_order=(0,1,1,12),   \n",
    "                                enforce_stationarity=False,\n",
    "                                enforce_invertibility=False)\n",
    "results2 = elecar_mod.fit()\n",
    "print(results2.summary().tables[1])\n",
    "print(\"/n\")\n",
    "\n",
    "blendcar_mod = sm.tsa.statespace.SARIMAX(blendcar['插电混动汽车销量'], \n",
    "                                order=(0,1,1), \n",
    "                                seasonal_order=(0,1,1,12),   \n",
    "                                enforce_stationarity=False,\n",
    "                                enforce_invertibility=False)\n",
    "results3 = blendcar_mod.fit()\n",
    "print(results3.summary().tables[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "3f2048bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "#预测新能源汽车未来1年的数据\n",
    "forecast1 = results1.get_forecast(steps= 18)\n",
    "forecast2 = results2.get_forecast(steps= 18)\n",
    "forecast3 = results3.get_forecast(steps= 18)\n",
    "\n",
    "# 得到预测的置信区间\n",
    "newcar_forecast = forecast1.predicted_mean\n",
    "elecar_forecast = forecast2.predicted_mean\n",
    "blendcar_forecast = forecast3.predicted_mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "68f3c2a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "newcar_result = newcar_preds['pred'][:1].tolist() + list(np.add(newcar_preds['pred'].tolist()[1:], newcar_forecast.tolist()))\n",
    "newcar_result = pd.DataFrame({\"pred\":newcar_result}, index=date_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "d8340643",
   "metadata": {},
   "outputs": [],
   "source": [
    "elecar_result = elecar_preds['pred'][:1].tolist() + list(np.add(elecar_preds['pred'].tolist()[1:], elecar_forecast.tolist()))\n",
    "elecar_result = pd.DataFrame({\"pred\":elecar_result}, index=date_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "c85692d1",
   "metadata": {},
   "outputs": [],
   "source": [
    "blendcar_result = blendcar_preds['pred'][:1].tolist() + list(np.add(blendcar_preds['pred'].tolist()[1:], blendcar_forecast.tolist()))\n",
    "blendcar_result = pd.DataFrame({\"pred\":blendcar_result}, index=date_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "928a8d3d",
   "metadata": {},
   "outputs": [],
   "source": [
    "newcar_result[:1] = newcar['新能源汽车销量'].values[-1]\n",
    "elecar_result[:1] = elecar['纯电动汽车销量'].values[-1]\n",
    "blendcar_result[:1] = blendcar['插电混动汽车销量'].values[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "c81c1bf7",
   "metadata": {},
   "outputs": [],
   "source": [
    "origin_index = list(pd.date_range(start=\"2017-01-01\",end=\"2022-07-01\",freq='MS'))\n",
    "predict_index = list(pd.date_range(start=\"2022-07-01\",end=\"2022-12-01\",freq='MS'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "a7916e90",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------新能源汽车------\n",
      "预测值的均方误差(MSE)是2013775966.54\n",
      "预测值的均方根误差(RMSE)是44875.1152\n",
      "预测值的平均绝对百分比误差(MAPE)是5.034717134064917\n",
      "预测值的R2是0.7335116852626578\n",
      "----纯电动汽车-----\n",
      "预测值的均方误差(MSE)是837042162.03\n",
      "预测值的均方根误差(RMSE)是28931.6809\n",
      "预测值的平均绝对百分比误差(MAPE)是4.929602203136543\n",
      "预测值的R2是0.8289781413403953\n",
      "----插电混动汽车-----\n",
      "预测值的均方误差(MSE)是85200000.0\n",
      "预测值的均方根误差(RMSE)是9230.3846\n",
      "预测值的平均绝对百分比误差(MAPE)是5.7230354470491935\n",
      "预测值的R2是0.7445702864756829\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'time')"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 3000x1200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABIYAAAFlCAYAAACeB+OLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC2UElEQVR4nOzdd1iT19sH8G8Ie1qVKSjUvXGLiruiVavi1tatrcWB1l23rahVi1tbq9j+tK5S6yut1r3rQLHuieLCVQUBWcnz/nFMIBAgQCCM7+e6cuXhPCfnOUASzc197iOTJEkCEREREREREREVO0aGngARERERERERERkGA0NERERERERERMUUA0NERERERERERMUUA0NERERERERERMUUA0NERERERERERMUUA0NERERERERERMUUA0NERERERERERMUUA0NERERERERERMUUA0NERERERERERMUUA0NERFRo3L9/HzKZDEFBQYaeilrLli3RsmVLQ09DJ2nnyp9nCnd3dwwaNCjfr6tv586dQ5MmTWBlZQWZTIawsDBDT4kMLCgoCDKZDOfPn8+yb05ffzKZDLNnz87+5ArodYiIihsGhoiIKFtUHzJUN2NjY5QpUwaDBg3C48ePDT09ygenTp3C7Nmz8ebNG0NPhVJJSkpCz5498d9//+H777/HL7/8gnLlyhl6WkQGd+3aNcyePRv379839FSIiAokY0NPgIiICqe5c+fCw8MD8fHx+OeffxAUFIQTJ07gypUrMDc3N/T0SAflypXDu3fvYGJikq3HnTp1CnPmzMGgQYNQokSJvJkcZdvdu3fx4MED/Pjjjxg2bJihp0OF0N9//23oKeSJa9euYc6cOWjZsiXc3d0NPR0iogKHgSEiIsqRDh06oH79+gCAYcOGoXTp0li4cCF2796NXr16GXh2RUtsbCysrKz0Pq5MJmMQrwh5/vw5ADBYlwfi4uJgaWlp6GnkOVNTU0NPgYiIDIBLyYiISC+8vb0BiKyF1G7cuIEePXqgZMmSMDc3R/369bF7926NPv/99x8mTJiAmjVrwtraGra2tujQoQMuXbqUo7noOt6RI0cgk8mwfft2fPvtt3B1dYW5uTnatGmDO3fupBv3hx9+QPny5WFhYYGGDRvi+PHjOs9JJpNh1KhR2Lx5MypXrgxzc3PUq1cPx44d0+g3e/ZsyGQyXLt2Df369cMHH3yAZs2aqc//73//Q7169WBhYYGSJUuiT58+ePjwYY7mmlGNoRs3bqBXr16wt7eHhYUFKleujK+//lo9v4kTJwIAPDw81EsKUy/R0OcctalRowZatWqVrl2pVKJMmTLo0aOHum3x4sVo0qQJSpUqBQsLC9SrVw87d+7M8hqq30NaqqWUaZek/PXXX/D29oaVlRVsbGzQsWNHXL16VaNPZGQkBg8eDFdXV5iZmcHZ2RldunTRaXnLoUOH1OOXKFECXbp0wfXr19XnBw0ahBYtWgAAevbsCZlMlmmtGNX3cfLkSYwfPx729vawsrJCt27d8OLFi3T9s/r+du/eDZlMhn///Vfd9ttvv0Emk8HX11djrKpVq6J3795Zfs9nzpxB+/btYWdnB0tLS7Ro0QInT57U6KP6Pd25c0edwWZnZ4fBgwcjLi4u3Zi6PDdbtmyJGjVqIDQ0FM2bN4elpSWmTZsGAHj16hU+++wz2NraokSJEhg4cCAuXbqk8TrauHEjZDIZLl68mO768+fPh1wuz3DZ7c6dOyGTyXD06NF059atWweZTIYrV66o23R5f1VJSEjI8netrcZQfHw8Zs+ejUqVKsHc3BzOzs7w9fVN916f1uPHjzFkyBA4OjrCzMwM1atXx4YNGzJ9TOq5jhs3Dvb29rCxscEnn3yCR48epev34MEDfPnll6hcuTIsLCxQqlQp9OzZU+M1FRQUhJ49ewIAWrVqpX7POnLkCADgjz/+QMeOHeHi4gIzMzOUL18e8+bNg0Kh0GmuRERFATOGiIhIL1T/Ef/ggw/UbVevXkXTpk1RpkwZTJkyBVZWVti+fTu6du2K3377Dd26dQMA3Lt3D7t27ULPnj3h4eGBZ8+eYd26dWjRogWuXbsGFxeXbM0lu+MtWLAARkZGmDBhAqKiorBo0SL0798fZ86cUff56aef8Pnnn6NJkybw9/fHvXv38Mknn6BkyZJwc3PTaV5Hjx7Ftm3bMGbMGJiZmWH16tVo3749zp49ixo1amj07dmzJypWrIj58+dDkiQAwLfffosZM2agV69eGDZsGF68eIEVK1agefPmuHjxojpTJDdz/ffff+Ht7Q0TExOMGDEC7u7uuHv3Lv7v//4P3377LXx9fXHr1i38+uuv+P7771G6dGkAgL29fb7NsXfv3pg9ezYiIyPh5OSkbj9x4gSePHmCPn36qNuWLVuGTz75BP3790diYiK2bt2Knj17Ys+ePejYsWPWvzQd/PLLLxg4cCB8fHywcOFCxMXFYc2aNWjWrBkuXryoXrrSvXt3XL16FaNHj4a7uzueP3+O/fv3IyIiItPlLQcOHECHDh3w4YcfYvbs2Xj37h1WrFiBpk2b4sKFC3B3d8fnn3+OMmXKYP78+RgzZgwaNGgAR0fHLOc+evRofPDBB5g1axbu37+PwMBAjBo1Ctu2bcvW99esWTPIZDIcO3YMtWrVAgAcP34cRkZGOHHihHqsFy9e4MaNGxg1alSm8zp06BA6dOiAevXqYdasWTAyMsLGjRvRunVrHD9+HA0bNtTo36tXL3h4eCAgIAAXLlzA+vXr4eDggIULF6r76PrcBEQAqEOHDujTpw8+/fRTODo6QqlUonPnzjh79ixGjhyJKlWq4I8//sDAgQM15tKjRw/4+flh8+bNqFOnjsa5zZs3o2XLlihTpozW77tjx46wtrbG9u3b1YE+lW3btqF69erq9wpd319VdPldp6VQKNCpUyccPHgQffr0wdixY/H27Vvs378fV65cQfny5bU+7tmzZ2jcuLE6IG5vb4+//voLQ4cORXR0NPz9/TO8JiCyUP/3v/+hX79+aNKkCQ4dOqT19Xru3DmcOnUKffr0gaurK+7fv481a9agZcuWuHbtGiwtLdG8eXOMGTMGy5cvx7Rp01C1alUAUN8HBQXB2toa48ePh7W1NQ4dOoSZM2ciOjoa3333XabzJCIqMiQiIqJs2LhxowRAOnDggPTixQvp4cOH0s6dOyV7e3vJzMxMevjwobpvmzZtpJo1a0rx8fHqNqVSKTVp0kSqWLGiui0+Pl5SKBQa1wkPD5fMzMykuXPnarQBkDZu3JjpHHUd7/DhwxIAqWrVqlJCQoK6fdmyZRIA6fLly5IkSVJiYqLk4OAgeXp6avT74YcfJABSixYtMp2PJEkSAAmAdP78eXXbgwcPJHNzc6lbt27qtlmzZkkApL59+2o8/v79+5JcLpe+/fZbjfbLly9LxsbG6vbszFXbz7N58+aSjY2N9ODBA43rKJVK9fF3330nAZDCw8PzfI7a3Lx5UwIgrVixQqP9yy+/lKytraW4uDh1W+pj1bVr1KghtW7dWqO9XLly0sCBA9Vfq34Paame/6rv/e3bt1KJEiWk4cOHa/SLjIyU7Ozs1O2vX7+WAEjfffddpt+bNp6enpKDg4P06tUrddulS5ckIyMjacCAAeo21fN5x44dWY6p+j7atm2r8bsdN26cJJfLpTdv3mTr+5MkSapevbrUq1cv9dd169aVevbsKQGQrl+/LkmSJAUHB0sApEuXLmU4N6VSKVWsWFHy8fHRmFtcXJzk4eEhffTRR+o21e9pyJAhGmN069ZNKlWqlPprXZ+bkiRJLVq0kABIa9eu1ej722+/SQCkwMBAdZtCoZBat26d7nXUt29fycXFReN96MKFCzq9f/Xt21dycHCQkpOT1W1Pnz6VjIyMNN6/dH1/1fV3rfreU7/+NmzYIAGQli5dmm6eqccCIM2aNUv99dChQyVnZ2fp5cuXGo/p06ePZGdnl+51mVpYWJgEQPryyy812vv165fuOtrGOX36tARA+vnnn9VtO3bskABIhw8fTtdf2xiff/65ZGlpqfGzJSIqyriUjIiIcqRt27awt7eHm5sbevToASsrK+zevRuurq4AxHKuQ4cOoVevXnj79i1evnyJly9f4tWrV/Dx8cHt27fVyynMzMxgZCT+SVIoFHj16hWsra1RuXJlXLhwIdtzy+54gwcP1qitoVoWd+/ePQDA+fPn8fz5c3zxxRca/QYNGgQ7Ozud5+Xl5YV69eqpvy5btiy6dOmCffv2pVu28MUXX2h8HRwcDKVSiV69eql/li9fvoSTkxMqVqyIw4cP53quL168wLFjxzBkyBCULVtW45y2ZVVp5cccAaBSpUrw9PTUyHRQKBTYuXMnOnfuDAsLC3V76uPXr18jKioK3t7eOXpeabN//368efMGffv21fie5XI5GjVqpP6eLSwsYGpqiiNHjuD169c6j//06VOEhYVh0KBBKFmypLq9Vq1a+Oijj/Dnn3/mav4jRozQ+N16e3tDoVDgwYMH2fr+VI9VLQd8+/YtLl26hBEjRqB06dLq9uPHj6NEiRLpMuRSCwsLw+3bt9GvXz+8evVKfc3Y2Fi0adMGx44dg1Kp1HhM2teLt7c3Xr16hejoaAC6PzdVzMzMMHjwYI22vXv3wsTEBMOHD1e3GRkZwc/PL933MGDAADx58kRj3M2bN8PCwgLdu3fP8HsHREbc8+fP1UudALHETKlUqpfgZef9VSWr37U2v/32G0qXLo3Ro0enO5fRe4IkSfjtt9/QuXNnSJKk8fP28fFBVFRUpq8/1XN6zJgxGu3asoxSv76TkpLw6tUrVKhQASVKlND5NZ56DNXP0tvbG3Fxcbhx44ZOYxARFXZcSkZERDmyatUqVKpUCVFRUdiwYQOOHTsGMzMz9fk7d+5AkiTMmDEDM2bM0DrG8+fPUaZMGSiVSixbtgyrV69GeHi4RpCkVKlS2Z5bdsdLGwRRLYdTfYBXfXCqWLGiRj8TExN8+OGHOs8r7eMBEeSIi4vDixcvNJZFeXh4aPS7ffs2JEnSOoZqLrmdqyoQltmH9szkxxxVevfujWnTpuHx48coU6YMjhw5gufPn6erXbNnzx588803CAsLQ0JCgrpdl0CXLm7fvg0AaN26tdbztra2AESgYeHChfjqq6/g6OiIxo0bo1OnThgwYIDG7z0t1c+qcuXK6c5VrVoV+/bty1Vx8qye+7p+f4AINKxduxZ37tzB3bt3IZPJ4OXlpQ4YDR8+HMePH0fTpk3VgVttVNdMu0QrtaioKI1lq5l9H7a2tjo/N1XKlCmTrhDzgwcP4OzsnK4IdYUKFdKN99FHH8HZ2RmbN29GmzZtoFQq8euvv6JLly6wsbHJ8PsCoK6rtG3bNrRp0waAWEbm6emJSpUqAcje+6tKVr9rbe7evYvKlSvD2Fj3jwwvXrzAmzdv8MMPP+CHH37IcG4ZefDgAYyMjNItU9P2Gnj37h0CAgKwceNGPH78WL3sFhDPEV1cvXoV06dPx6FDh9SBxOyOQURU2DEwREREOdKwYUP1rmRdu3ZFs2bN0K9fP9y8eRPW1tbqv+hPmDABPj4+WsdQfaCaP38+ZsyYgSFDhmDevHkoWbIkjIyM4O/vny4zQBfZHU8ul2sdJ/WHjPyW+q/YgAh2yWQy/PXXX1rna21tnV9Ty1B+zrF3796YOnUqduzYAX9/f2zfvh12dnZo3769us/x48fxySefoHnz5li9ejWcnZ1hYmKCjRs3YsuWLZmOn1HgKG1ml+r59Msvv2gN8KT+QO3v74/OnTtj165d2LdvH2bMmIGAgAAcOnQoXS2a/JLVcz8735+qSPqxY8dw79491K1bF1ZWVvD29sby5csRExODixcv4ttvv810Tqprfvfdd/D09NTaJ+1zSZfvIzvPzbSvv+ySy+Xo168ffvzxR6xevRonT57EkydP8Omnn2b5WDMzM3Tt2hW///47Vq9ejWfPnuHkyZOYP3++uk923l9Tz0kbfb/Pqeb26aefZhjcU9Whyq3Ro0dj48aN8Pf3h5eXF+zs7CCTydCnTx+d/u148+YNWrRoAVtbW8ydOxfly5eHubk5Lly4gMmTJ+fo3x8iosKIgSEiIso1uVyOgIAAtGrVCitXrsSUKVPUmR8mJiZo27Ztpo/fuXMnWrVqhZ9++kmj/c2bN+rixtmh7/HKlSsHQGQypM6cSEpKQnh4OGrXrq3TOKpMiNRu3boFS0tLdfHmjJQvXx6SJMHDw0OdNaDvuap+Z6l3PdImo6BJfsxRxcPDAw0bNsS2bdswatQoBAcHo2vXrhpZa7/99hvMzc2xb98+jfaNGzdmOb4qm+LNmzcaRYnTLrtRZTU4ODhk+TxX9f/qq6/w1Vdf4fbt2/D09MSSJUvwv//9T2t/1c/q5s2b6c7duHEDpUuXznG2kC6y8/2VLVsWZcuWxfHjx3Hv3j31kszmzZtj/Pjx2LFjBxQKBZo3b67TNW1tbXX6mepC1+dmZsqVK4fDhw+n27pe2w6GgFhOtmTJEvzf//0f/vrrL9jb22cYxEmrd+/e2LRpEw4ePIjr169DkiSNbLjsvL/mRvny5XHmzBkkJSWly6rKiGonMYVCkaO5lStXDkqlUp2tpKLtNbBz504MHDgQS5YsUbfFx8fjzZs3Gv0yes86cuQIXr16heDgYI3nZXh4eLbnTURUmLHGEBER6UXLli3RsGFDBAYGIj4+Hg4ODmjZsiXWrVuHp0+fpuufeptkuVye7q/WO3bsyHBL56zoe7z69evD3t4ea9euRWJioro9KCgo3QeQzJw+fVqj7sXDhw/xxx9/oF27dhn+NV/F19cXcrkcc+bMSfe9SZKEV69e5Xqu9vb2aN68OTZs2ICIiIh011BRBSLSjpcfc0ytd+/e+Oeff7Bhwwa8fPky3TIyuVwOmUymkeVz//597Nq1K8uxVcGJY8eOqdtiY2OxadMmjX4+Pj6wtbXF/PnzkZSUlG4c1fM8Li4O8fHx6a5hY2OjscQtLWdnZ3h6emLTpk0aP5srV67g77//xscff5zl95Ibun5/Kt7e3jh06BDOnj2rDgx5enrCxsYGCxYsgIWFhUadLW3q1auH8uXLY/HixYiJicnymrrQ9bmZGR8fHyQlJeHHH39UtymVSqxatUpr/1q1aqFWrVpYv349fvvtN/Tp00fnJVlt27ZFyZIlsW3bNmzbtg0NGzbUWF6anffX3OjevTtevnyJlStXpjuXUaaRXC5H9+7d8dtvv2kNMmc1tw4dOgAAli9frtEeGBio9Vpp57FixYp0mX0ZvWep3ndTj5GYmIjVq1dnOkcioqKGGUNERKQ3EydORM+ePREUFIQvvvgCq1atQrNmzVCzZk0MHz4cH374IZ49e4bTp0/j0aNHuHTpEgCgU6dOmDt3LgYPHowmTZrg8uXL2Lx5c7bq96Sm7/FMTEzwzTff4PPPP0fr1q3Ru3dvhIeHY+PGjdkas0aNGvDx8dHYrh4A5syZk+Vjy5cvj2+++QZTp07F/fv30bVrV9jY2CA8PBy///47RowYgQkTJuR6rsuXL0ezZs1Qt25djBgxAh4eHrh//z5CQkIQFhYGAOoP9l9//TX69OkDExMTdO7cOd/mqNKrVy9MmDABEyZMQMmSJdNlJ3Ts2BFLly5F+/bt0a9fPzx//hyrVq1ChQoV8O+//2Y6drt27VC2bFkMHToUEydOhFwux4YNG2Bvb68RNLO1tcWaNWvw2WefoW7duujTp4+6T0hICJo2bYqVK1fi1q1baNOmDXr16oVq1arB2NgYv//+O549e4Y+ffpkOpfvvvsOHTp0gJeXF4YOHarert7Ozg6zZ8/W+eeVE7p+fyre3t7YvHkzZDKZemmZXC5HkyZNsG/fPrRs2TJd7Z60jIyMsH79enTo0AHVq1fH4MGDUaZMGTx+/BiHDx+Gra0t/u///i9b34euz83MdO3aFQ0bNsRXX32FO3fuoEqVKti9ezf+++8/ANqzUgYMGKAeV5dlZComJibw9fXF1q1bERsbi8WLF6fro+v7a24MGDAAP//8M8aPH68O9sXGxuLAgQP48ssv0aVLF62PW7BgAQ4fPoxGjRph+PDhqFatGv777z9cuHABBw4cUP/MtPH09ETfvn2xevVqREVFoUmTJjh48KDWzKxOnTrhl19+gZ2dHapVq4bTp0/jwIED6WrJeXp6Qi6XY+HChYiKioKZmRlat26NJk2a4IMPPsDAgQMxZswYyGQy/PLLLwZdRkxEZBD5svcZEREVGaqtj8+dO5funEKhkMqXLy+VL19evdXy3bt3pQEDBkhOTk6SiYmJVKZMGalTp07Szp071Y+Lj4+XvvrqK8nZ2VmysLCQmjZtKp0+fTrd1snZ2a5el/Ey2t47o+usXr1a8vDwkMzMzKT69etLx44dSzdmRgBIfn5+0v/+9z+pYsWKkpmZmVSnTp102yertt9+8eKF1nF+++03qVmzZpKVlZVkZWUlValSRfLz85Nu3ryZ7blm9H1euXJF6tatm1SiRAnJ3Nxcqly5sjRjxgyNPvPmzZPKlCkjGRkZpdu6Xp9zzErTpk0lANKwYcO0nv/pp5/UP+8qVapIGzdu1LoVfdrt6iVJkkJDQ6VGjRpJpqamUtmyZaWlS5em265e5fDhw5KPj49kZ2cnmZubS+XLl5cGDRoknT9/XpIkSXr58qXk5+cnValSRbKyspLs7OykRo0aSdu3b9fp+zxw4IDUtGlTycLCQrK1tZU6d+4sXbt2Ld0ctD2ftcnodawaI+3zMqvvT+Xq1asSAKlq1aoa7d98840EIN3zKDMXL16UfH19pVKlSklmZmZSuXLlpF69ekkHDx5U98no9ZLR70mX52aLFi2k6tWra53TixcvpH79+kk2NjaSnZ2dNGjQIOnkyZMSAGnr1q3p+j99+lSSy+VSpUqVdP6+Vfbv3y8BkGQymfTw4UOtfXR5f83O71rb6y8uLk76+uuvJQ8PD8nExERycnKSevToId29e1fdB2m2kZckSXr27Jnk5+cnubm5qR/Xpk0b6Ycffsjye3/37p00ZswYqVSpUpKVlZXUuXNn6eHDh+mu8/r1a2nw4MFS6dKlJWtra8nHx0e6ceOG1tfzjz/+KH344YeSXC7X+L5PnjwpNW7cWLKwsJBcXFykSZMmSfv27ctwe3sioqJIJkkMiRMREeU1mUwGPz8/rUsyiKjw2rVrF7p164YTJ06gadOmGudevnwJZ2dnzJw5M8Pdw4iIiAyNNYaIiIiIiHTw7t07ja8VCgVWrFgBW1tb1K1bN13/oKAgKBQKfPbZZ/k1RSIiomxjjSEiIiIiIh2MHj0a7969g5eXFxISEhAcHIxTp05h/vz5GlvcHzp0CNeuXcO3336Lrl27wt3d3XCTJiIiygIDQ0REREREOmjdujWWLFmCPXv2ID4+HhUqVMCKFSswatQojX5z587FqVOn0LRpU6xYscJAsyUiItINawwRERERERERERVTrDFERERERERERFRMMTBERERERERERFRMscZQPlIqlXjy5AlsbGwgk8kMPR0iIiIiIiIiKqIkScLbt2/h4uICI6OM84IYGMpHT548gZubm6GnQURERERERETFxMOHD+Hq6prheQaG8pGNjQ0A8UuxtbU18GyIiIiIiIiIhNjEWLgscQEAPPnqCaxMrQw8I8qt6OhouLm5qWMRGWFgKB+plo/Z2toyMEREREREREQFhjxRDpiLY1tbWwaGipCsStmw+DQRERERERERUTHFwBARERERERERUTHFwBARERERERERUTHFGkMFkEKhQFJSkqGnQcWAqalpptsWEhERERERUdHGwFABIkkSIiMj8ebNG0NPhYoJIyMjeHh4wNTU1NBTISIiIiIiA7IytYI0SzL0NAoOhQI4fhx4+hRwdga8vQG53NCzyhMMDBUgqqCQg4MDLC0ts6wcTpQbSqUST548wdOnT1G2bFk+34iIiIiIiAAgOBgYOxZ49CilzdUVWLYM8PU13LzyCANDBYRCoVAHhUqVKmXo6VAxYW9vjydPniA5ORkmJiaGng4REREREZFhBQcDPXoAUprsqcePRfvOnUUuOMTiIgWEqqaQpaWlgWdCxYlqCZlCoTDwTIiIiIiIyJDik+PRc0dP9NzRE/HJ8YaejmEoFCJTKG1QCEhp8/cX/YoQBoYKGC7nofzE5xsREREREQGAQqnAzms7sfPaTiiURSjwoVAAR44Av/4q7jML6hw/rrl8LC1JAh4+FP2KEC4lIyIiIiIiIqKiR9daQY8fA/v3Az/+qNu4T5/qd54GxowhMojZs2fD09MzW49p2bIl/P39DT6P7AoKCkKJEiXy9BpERERERESUiqpWUNoMIFWtoGnTRNCoWjURLBo8GDh1SrexnZ31P18DYsZQUVNIttSbMGECRo8ena3HBAcHs0AyERERERERZU6XWkEBASltRkZA/fpAmzbA+vXAy5faHyuTiSCSt3fezNtAGBgqSgrBlnqSJEGhUMDa2hrW1tbZemzJkiXzaFZERERERERUZGRVK0ilc2dg0CCgVSvggw9EW/36IqNIJtMMDqnqswYGFsjki9zgUrKiIqs0ueDgPLlsQkICxowZAwcHB5ibm6NZs2Y4d+6c+vyRI0cgk8nw119/oV69ejAzM8OJEyfSLeFKTk7GmDFjUKJECZQqVQqTJ0/GwIED0bVrV3WftEvJ3N3dMX/+fAwZMgQ2NjYoW7YsfvjhB435TZ48GZUqVYKlpSU+/PBDzJgxQ70DXFaUSiVcXV2xZs0ajfaLFy/CyMgIDx48AAAsXboUNWvWhJWVFdzc3PDll18iJiYmw3EHDRqk8X0BgL+/P1q2bKlx7YCAAHh4eMDCwgK1a9fGzp07dZo3ERERERFRsaZrDaC+fUUShSooBIivd+4EXFw0+7q6Fsmt6gEGhgouSQJiY3W7RUcDY8ZkniY3dqzop8t42sbJwKRJk/Dbb79h06ZNuHDhAipUqAAfHx/8999/Gv2mTJmCBQsW4Pr166hVq1a6cRYuXIjNmzdj48aNOHnyJKKjo7Fr164sr79kyRLUr18fFy9exJdffomRI0fi5s2b6vM2NjYICgrCtWvXsGzZMvz444/4/vvvdfrejIyM0LdvX2zZskWjffPmzWjatCnKlSun7rd8+XJcvXoVmzZtwqFDhzBp0iSdrpGRgIAA/Pzzz1i7di2uXr2KcePG4dNPP8XRo0dzNS4REREREVGRp2sNIG39EmOBTj7A1fPAQEvA1wL483fg5hXRXgQZPDD0+PFjfPrppyhVqhQsLCxQs2ZNnD9/Xn1ekiTMnDkTzs7OsLCwQNu2bXH79m2NMf777z/0798ftra2KFGiBIYOHZouY+Pff/+Ft7c3zM3N4ebmhkWLFqWby44dO1ClShWYm5ujZs2a+PPPPzXO6zIXvYmLA6ytdbvZ2YnMoIxIksgksrPTbby4OJ2mGBsbizVr1uC7775Dhw4dUK1aNfz444+wsLDATz/9pNF37ty5+Oijj1C+fHmtS8JWrFiBqVOnolu3bqhSpQpWrlypU8Hmjz/+GF9++SUqVKiAyZMno3Tp0jh8+LD6/PTp09GkSRO4u7ujc+fOmDBhArZv367T9wcA/fv3x8mTJxEREQFAZPJs3boV/fv3V/fx9/dHq1at4O7ujtatW+Obb77J1jXSSkhIwPz587Fhwwb4+Pjgww8/xKBBg/Dpp59i3bp1OR6XiIiIiIgoI5YmloiZGoOYqTGwNLE09HRyx9tbZPioln+lJZMBbm7aawXNdxG37ysD7sZATRPgzEBgoZtoL4IMGhh6/fo1mjZtChMTE/z111+4du0alixZgg9SpXEtWrQIy5cvx9q1a3HmzBlYWVnBx8cH8fHx6j79+/fH1atXsX//fuzZswfHjh3DiBEj1Oejo6PRrl07lCtXDqGhofjuu+8we/ZsjWVHp06dQt++fTF06FBcvHgRXbt2RdeuXXHlypVszaU4uXv3LpKSktC0aVN1m4mJCRo2bIjr169r9K1fv36G40RFReHZs2do2LChuk0ul6NevXpZziF19pFMJoOTkxOeP3+ubtu2bRuaNm0KJycnWFtbY/r06eogjy48PT1RtWpVddbQ0aNH8fz5c/Ts2VPd58CBA2jTpg3KlCkDGxsbfPbZZ3j16hXidAywpXXnzh3ExcXho48+Utdisra2xs8//4y7d+/maEwiIiIiIqLMyGQyWJlawcrUCrKMAiqFhVwuau1mVEAaKJK1gnLKoMWnFy5cCDc3N2zcuFHd5uHhoT6WJAmBgYGYPn06unTpAgD4+eef4ejoiF27dqFPnz64fv069u7di3PnzqmDDytWrMDHH3+MxYsXw8XFBZs3b0ZiYiI2bNgAU1NTVK9eHWFhYVi6dKk6gLRs2TK0b98eEydOBADMmzcP+/fvx8qVK7F27Vqd5qJXlpZAJnVqNBw7Bnz8cdb9/vwTaN5ct2vrmZWVld7HBJBulzKZTAalUgkAOH36NPr37485c+bAx8cHdnZ22Lp1K5YsWZKta/Tv3x9btmzBlClTsGXLFrRv3x6lSpUCANy/fx+dOnXCyJEj8e2336JkyZI4ceIEhg4disTERFhq+VkaGRlBSvMGlbrukSrbLSQkBGXKlNHoZ2Zmlq25ExERERERFUs+PmJFTNrP1a6uIiiUUa2gaU/EfWIcsLiCOJ5wBzAt5FlUmTBoxtDu3btRv3599OzZEw4ODqhTpw5+/PFH9fnw8HBERkaibdu26jY7Ozs0atQIp0+fBiA+/JcoUUIjI6Vt27YwMjLCmTNn1H2aN28OU1NTdR8fHx/cvHkTr1+/VvdJfR1VH9V1dJlLWgkJCYiOjta46UwmA6ysdLu1a6dbmly7drqNp2N0uHz58jA1NcXJkyfVbUlJSTh37hyqVaum87dqZ2cHR0dHjaLVCoUCFy5c0HkMbU6dOoVy5crh66+/Rv369VGxYkV1wejs6NevH65cuYLQ0FDs3LlTYxlZaGgolEollixZgsaNG6NSpUp48uRJpuPZ29vjaZpiaGFhYerjatWqwczMDBEREahQoYLGzc3NLdvzJyIiIiIiykpCcgIG7RqEQbsGISE5wdDTyb0NG0RQyMMDOHAA2LIFOHwYCA/PvIC0qdX7W6pAkKllSnsRZNDA0L1797BmzRpUrFgR+/btw8iRIzFmzBhs2rQJABAZGQkAcHR01Hico6Oj+lxkZCQcHBw0zhsbG6NkyZIafbSNkfoaGfVJfT6ruaQVEBAAOzs79S3PPtSr0uSA9EGdPEyTs7KywsiRIzFx4kTs3bsX165dw/DhwxEXF4ehQ4dma6zRo0cjICAAf/zxB27evImxY8fi9evXuUphrFixIiIiIrB161bcvXsXy5cvx++//57tcdzd3dGkSRMMHToUCoUCn3zyifpchQoVkJSUhBUrVuDevXv45ZdfsHbt2kzHa926Nc6fP4+ff/4Zt2/fxqxZszSWLNrY2GDChAkYN24cNm3ahLt37+LChQtYsWKF+rVBRERERESkT8nKZGy6tAmbLm1CsjLZ0NPJnaQkYPFicTx+LHDcF7j5BdCkAZePaWHQwJBSqUTdunUxf/581KlTByNGjMDw4cOz/GBdWEydOhVRUVHq28OHD/PuYqot9dIsPcrrLfUWLFiA7t2747PPPkPdunVx584d7Nu3T6NOlC4mT56Mvn37YsCAAfDy8oK1tTV8fHxgbm6e47l98sknGDduHEaNGgVPT0+cOnUKM2bMyNFY/fv3x6VLl9CtWzdYWFio22vXro2lS5di4cKFqFGjBjZv3oyAgIBMx/Lx8cGMGTMwadIkNGjQAG/fvsWAAQM0+sybNw8zZsxAQEAAqlativbt2yMkJERjqSURERERERFpsW0bEBEBODgAn/XPur82plbA7ChxK6KZQioyKW2xk3xUrlw5fPTRR1i/fr26bc2aNfjmm2/w+PFj3Lt3D+XLl8fFixfh6emp7tOiRQt4enpi2bJl2LBhA7766iv1kjAASE5Ohrm5OXbs2IFu3bphwIAB6bY/P3z4MFq3bo3//vsPH3zwAcqWLYvx48fD399f3WfWrFnYtWsXLl26pNNcshIdHQ07OztERUXB1tZW41x8fDzCw8Ph4eGRq2AIFArg+HHg6VOx9Z63d6GMiCqVSlStWhW9evXCvHnzDD2dIktvzzsiIiIiIirUYhNjYR1gDQCImRoDq8IaDJEkoFYt4MoVYN5swP9L7bWCCuv3lw2ZxSBSM2jGUNOmTXHz5k2Ntlu3bqFcuXIARCFqJycnHDx4UH0+OjoaZ86cgZeXFwDAy8sLb968QWhoqLrPoUOHoFQq0ahRI3WfY8eOaRT43b9/PypXrqzObPHy8tK4jqqP6jq6zKVAkMuBli2Bvn3FfSEJCj148AA//vgjbt26hcuXL2PkyJEIDw9Hv379DD01IiIiIiIiKiz+/FMEhUwBxCxJCQoB4li1HT2pGTQwNG7cOPzzzz+YP38+7ty5gy1btuCHH36An58fALHDlL+/P7755hvs3r0bly9fxoABA+Di4oKuXbsCgHqZzfDhw3H27FmcPHkSo0aNQp8+feDiIn7Z/fr1g6mpKYYOHYqrV69i27ZtWLZsGcaPH6+ey9ixY7F3714sWbIEN27cwOzZs3H+/HmMGjVK57lQzhkZGSEoKAgNGjRA06ZNcfnyZRw4cABVq1Y19NSIiIiIiIiosFiwQNzXNwXMc16ztjgx6Hb1DRo0wO+//46pU6di7ty58PDwQGBgoMauT5MmTUJsbCxGjBiBN2/eoFmzZti7d6/GspfNmzdj1KhRaNOmDYyMjNC9e3csX75cfd7Ozg5///03/Pz8UK9ePZQuXRozZ85Ub1UPAE2aNMGWLVswffp0TJs2DRUrVsSuXbtQo0aNbM2FcsbNzU1jdzMiIiIiIiKibDl5EjhxAjA1BTZfBVyci9W28zll0BpDxU2+1BgiygY+74iIiIiICCgiNYY++QT4v/8Dhg0DfvxRtCXGpiwdm/akWNQWUtG1xpBBM4aIiIiIiIiIyPAsTSzxfMJz9XGhc/WqCArJZMDEiYaeTaHCwBARERERERFRMSeTyWBvZW/oaeTcokXi3tcXqFQppV217TxlyKDFp4mIiIiIiIiIciUiAtiyRRxPnmzYuRRCDAwRERERERERFXMJyQnwC/GDX4gfEpITDD2d7Fm6FEhOBlq3Bho0MPRsCh0GhoiIiIiIiIiKuWRlMlafX43V51cjWZls6Ono7tWrlELTzBbKEQaGKFckScKIESNQsmRJyGQyhIWFoWXLlvD398+3OQQFBaFEiRJ5eo0jR45AJpPhzZs3eXodIiIiIiIiyoaVK4G4OKBOHeCjjww9m0KJgSHKlb179yIoKAh79uzB06dPUaNGDQQHB2PevHnqPu7u7ggMDNR4XH4Ec4iIiIiIiKgASowFZtuJW2JszseJjQVWrBDHkyeLHcko27grGeXK3bt34ezsjCZNmqjbSpYsacAZERERERERUbHw009iKVn58kD37oaeTaHFjKEiJi4xGe5TQuA+JQRxiXm7LnTQoEEYPXo0IiIiIJPJ4O7uDgAaS8latmyJBw8eYNy4cZDJZJDJZDhy5AgGDx6MqKgoddvs2bMBAAkJCZgwYQLKlCkDKysrNGrUCEeOHNG4blBQEMqWLQtLS0t069YNr169ynSeTZo0weQ0a01fvHgBExMTHDt2DADwyy+/oH79+rCxsYGTkxP69euH58+fZzjm7Nmz4enpqdEWGBio/hmorF+/HlWrVoW5uTmqVKmC1atXZzpXIiIiIiKiIisx9v0tLlVbXEp7diQlAUuWiOMJEwBj5r3kFANDlGPLli3D3Llz4erqiqdPn+LcuXPp+gQHB8PV1RVz587F06dP8fTpUzRp0gSBgYGwtbVVt02YMAEAMGrUKJw+fRpbt27Fv//+i549e6J9+/a4ffs2AODMmTMYOnQoRo0ahbCwMLRq1QrffPNNpvPs378/tm7dCkmS1G3btm2Di4sLvL29AQBJSUmYN28eLl26hF27duH+/fsYNGhQrn4+mzdvxsyZM/Htt9/i+vXrmD9/PmbMmIFNmzblalwiIiIiIqJCab6LuC2ukNK2uEJKe3Zs3Sq2qXd0BHL52a24Y0itiFBlB8UlKlK1pRxbmur/V21nZwcbGxvI5XI4OTlp7VOyZEnI5XJ1Jk7qx8pkMo22iIgIbNy4EREREXBxEW8KEyZMwN69e7Fx40bMnz8fy5YtQ/v27TFp0iQAQKVKlXDq1Cns3bs3w3n26tUL/v7+OHHihDoQtGXLFvTt2xey92tQhwwZou7/4YcfYvny5WjQoAFiYmJgbW2do5/PrFmzsGTJEvj6+gIAPDw8cO3aNaxbtw4DBw7M0ZhERERERETFnlIJLFwojseOBczNDTufQo6BoSKi2sx96drqf3NAfXx/Qcf8nE6OXL58GQqFApUqVdJoT0hIQKlSpQAA169fR7du3TTOe3l5ZRoYsre3R7t27bB582Z4e3sjPDwcp0+fxrp169R9QkNDMXv2bFy6dAmvX7+GUqkEIIJV1apVy/b3Ehsbi7t372Lo0KEYPny4uj05ORl2dnbZHo+IiIiIiCgvWZhYIHxsuPo4T0x7Iu4T41KyhibcAUwtdXu8QgEcPw6EhABXrwLW1sDIkXkz12KEgSEqMGJiYiCXyxEaGgq5XK5xLqdZOyr9+/fHmDFjsGLFCmzZsgU1a9ZEzZo1AYggjo+PD3x8fLB582bY29sjIiICPj4+SExM1DqekZGRxtI0QCxHS/29AMCPP/6IRo0aafRL+70REREREREZmpHMCO4l3PP2IqZW4l6hAO4nA28l4PR5oHU7IKvPScHBIjvo0SPN9kOHgPerNChnGBgqIq7N9QEglo+pMoXOT28LS1PDByFMTU2hUCiybKtTpw4UCgWeP3+uXvKVVtWqVXHmzBmNtn/++SfLOXTp0gUjRozA3r17sWXLFgwYMEB97saNG3j16hUWLFgANzc3AMD58+czHc/e3h6RkZGQJEm9HC0sLEx93tHRES4uLrh37x769++f5fyIiIiIiIiKheBgYMwY4PH7AtTBHwOursCyZRkHeIKDgR49gDR/nEdsrGjfuZPBoVxg8ekiwtLU+P1NnqpNrm43JHd3dxw7dgyPHz/Gy5cv1W0xMTE4ePAgXr58ibi4OFSqVAn9+/fHgAEDEBwcjPDwcJw9exYBAQEICQkBAIwZMwZ79+7F4sWLcfv2baxcuTLTZWQqVlZW6Nq1K2bMmIHr16+jb9++6nNly5aFqakpVqxYgXv37mH37t2YN29epuO1bNkSL168wKJFi3D37l2sWrUKf/31l0afOXPmICAgAMuXL8etW7dw+fJlbNy4EUuXLs3uj5CIiIiIiChPJSoSMfHviZj490QkKrSvnMg1VYDn8WPN9sePRXtwcPrHKBQiUyhtUAhIafP3F/0oRxgYojw3d+5c3L9/H+XLl4e9vT0AsYX8F198gd69e8Pe3h6LFi0CAGzcuBEDBgzAV199hcqVK6Nr1644d+4cypYtCwBo3LgxfvzxRyxbtgy1a9fG33//jenTp+s0j/79++PSpUvw9vZWjweI7J+goCDs2LED1apVw4IFC7B48eJMx6patSpWr16NVatWoXbt2jh79qx6ZzWVYcOGYf369di4cSNq1qyJFi1aICgoCB4eHjr/7IiIiIiIiPJDkiIJi08vxuLTi5GkSMr6AdmlS4BnzBjgzh0gLAw4cgT44w9g+vT0y8fSPvbhQ1F7iHJEJqUtlEJ5Jjo6GnZ2doiKioKtra3Gufj4eISHh8PDwwPmrKhO+YTPOyIiIiIiAoDYxFhYB4jarjFTY2ClqgekL0eOAK1a6XfM1LZsAVKtDKHMYxCpscYQEREREREREeWtp09162diApQqBZQoAdjZiUyjLGrAAgCcnXM1veKMgSEiIiIiIiIiyjt37wK//KJb37//Blq2TPlaoQDKlQOePNG+DE0mE8WrM9jAiLLGGkNERERERERElH0KhVgi9uuv4j5tAehbt4CBA4HKlYE0m/WkI5MBbm7pAzxyObB8eUqftI8BgMDArLe7pwwxMERERERERERE2RMcDLi7i7pB/fqJe3d30X79OvDpp0DVqsDPP4uA0ccfAwEBIpiT3QCPr6/Ykt7FRbPd1ZVb1esBl5IRERERERERke5U286nXdr1+DHQvbtm2yefADNmAPXri68rVRK7k6XeaczVVQSFMgvw+PoCXbqI3ceePhU1hby9mSmkBwwMERERERERERVzFiYWuDLyivo4Q7psOw8A3bqJgFCdOpp9chPgkcs16w+RXjAwRERERERERFTMGcmMUN2hetYdjx/XzPbJyJgx6YNCKgzwFCisMUREREREREREutF123ld+5HBMWOIiIiIiIiIqJhLVCRi/vH5AIBp3tNgKjfV3tHZWbcBde1HBseMISpU3N3dERgYqP5aJpNh165d+T6P2bNnw9PTM0+vERQUhBIlSuTpNYiIiIiIiAAgSZGEOUfnYM7ROUhSJGXc0dtbFItOu7OYSkbbzlOBxcAQFWpPnz5Fhw4ddOqbH8EcIiIiIiKiIk0uB5Yt0158Oqtt56lAYmCI8l1iYqLexnJycoKZmZnexiMiIiIiIqIsVK2qPWPI1RXYuTPzbeepwDFoYGj27NmQyWQatypVqqjPx8fHw8/PD6VKlYK1tTW6d++OZ8+eaYwRERGBjh07wtLSEg4ODpg4cSKSk5M1+hw5cgR169aFmZkZKlSogKCgoHRzWbVqFdzd3WFubo5GjRrh7NmzGud1mUuBkBgLzLYTt8TYPL9cy5YtMWrUKIwaNQp2dnYoXbo0ZsyYASlV9Njd3R3z5s3DgAEDYGtrixEjRgAATpw4AW9vb1hYWMDNzQ1jxoxBbGzKnJ8/f47OnTvDwsICHh4e2Lx5c7rrp11K9ujRI/Tt2xclS5aElZUV6tevjzNnziAoKAhz5szBpUuX1M811fPgzZs3GDZsGOzt7WFra4vWrVvj0qVLGtdZsGABHB0dYWNjg6FDhyI+Pj7Dn4lSqYSrqyvWrFmj0X7x4kUYGRnhwYMHAIClS5eiZs2asLKygpubG7788kvExMRkOO6gQYPQtWtXjTZ/f3+0TFXNX6lUIiAgAB4eHrCwsEDt2rWxc+fODMckIiIiIiLKtunTRcZQly7A4cPAli3iPjycQaFCyOAZQ9WrV8fTp0/VtxMnTqjPjRs3Dv/3f/+HHTt24OjRo3jy5Al8Uz3JFAoFOnbsiMTERJw6dQqbNm1CUFAQZs6cqe4THh6Ojh07olWrVggLC4O/vz+GDRuGffv2qfts27YN48ePx6xZs3DhwgXUrl0bPj4+eP78uc5zKc42bdoEY2NjnD17FsuWLcPSpUuxfv16jT6LFy9G7dq1cfHiRcyYMQN3795F+/bt0b17d/z777/Ytm0bTpw4gVGjRqkfM2jQIDx8+BCHDx/Gzp07sXr1ao3fSVoxMTFo0aIFHj9+jN27d+PSpUuYNGkSlEolevfuja+++krj+da7d28AQM+ePfH8+XP89ddfCA0NRd26ddGmTRv8999/AIDt27dj9uzZmD9/Ps6fPw9nZ2esXr06w3kYGRmhb9++2LJli0b75s2b0bRpU5QrV07db/ny5bh69So2bdqEQ4cOYdKkSdn74acREBCAn3/+GWvXrsXVq1cxbtw4fPrppzh69GiuxiUiIiIiIgIAnD0LBAcDRkbAt9+Kbef79hX3XD5WOEkGNGvWLKl27dpaz71580YyMTGRduzYoW67fv26BEA6ffq0JEmS9Oeff0pGRkZSZGSkus+aNWskW1tbKSEhQZIkSZo0aZJUvXp1jbF79+4t+fj4qL9u2LCh5Ofnp/5aoVBILi4uUkBAgM5z0UVUVJQEQIqKikp37t27d9K1a9ekd+/e6TyehoQYcXv7XJJm2Yrb2+cp7XmkRYsWUtWqVSWlUqlumzx5slS1alX11+XKlZO6du2q8bihQ4dKI0aM0Gg7fvy4ZGRkJL179066efOmBEA6e/as+rzqZ/7999+r2wBIv//+uyRJkrRu3TrJxsZGevXqlda5anu+HT9+XLK1tZXi4+M12suXLy+tW7dOkiRJ8vLykr788kuN840aNcrwuStJknTx4kVJJpNJDx48kCRJPKfKlCkjrVmzJsPH7NixQypVqpT6640bN0p2dnbqrwcOHCh16dJF4zFjx46VWrRoIUmSJMXHx0uWlpbSqVOnNPoMHTpU6tu3r9Zr5vp5R0RERERERUJMQoyE2ZAwG1JMRp8hlUpJatVKkgBJGjQofydI2ZZZDCI1g2cM3b59Gy4uLvjwww/Rv39/REREAABCQ0ORlJSEtm3bqvtWqVIFZcuWxenTpwEAp0+fRs2aNeHo6Kju4+Pjg+joaFy9elXdJ/UYqj6qMRITExEaGqrRx8jICG3btlX30WUu2iQkJCA6Olrjlmfmu4jb4gopbYsrpLTnocaNG0OWan2pl5cXbt++DYVCoW6rX7++xmMuXbqEoKAgWFtbq28+Pj5QKpUIDw/H9evXYWxsjHr16qkfU6VKlUx36QoLC0OdOnVQsmRJned+6dIlxMTEqJcIqm7h4eG4e/cuAOD69eto1KiRxuO8vLwyHdfT0xNVq1ZVZw0dPXoUz58/R8+ePdV9Dhw4gDZt2qBMmTKwsbHBZ599hlevXiEuLk7n+ad2584dxMXF4aOPPtL4Xn7++Wf190JERERERJRjBw6IJWOmpsDs2YaeDemJsSEv3qhRIwQFBaFy5cp4+vQp5syZA29vb1y5cgWRkZEwNTVNFwhwdHREZGQkACAyMlIjKKQ6rzqXWZ/o6Gi8e/cOr1+/hkKh0Nrnxo0b6jGymos2AQEBmDNnjm4/jCLOyspK4+uYmBh8/vnnGDNmTLq+ZcuWxa1bt7J9DQsLi2w/JiYmBs7Ozjhy5Ei6c7ndKr5///7YsmULpkyZgi1btqB9+/YoVaoUAOD+/fvo1KkTRo4ciW+//RYlS5bEiRMnMHToUCQmJsLS0jLdeEZGRhq1mwAgKSllG0lVfaKQkBCUKVNGox8LdBMRERERUWbMjc1xdthZ9XE6SiUwdao4/vJL4H2JDCr8DBoYSr3NeK1atdCoUSOUK1cO27dvz9GH/IJm6tSpGD9+vPrr6OhouLm55c3Fpj0R94lxKVlDE+4ApukDDPp25swZja//+ecfVKxYEfJM1pfWrVsX165dQ4UKFbSer1KlCpKTkxEaGooGDRoAAG7evIk3b95kOGatWrWwfv16/Pfff1qzhkxNTTWymFTziIyMhLGxMdzd3bWOW7VqVZw5cwYDBgzQ+B6z0q9fP0yfPh2hoaHYuXMn1q5dqz4XGhoKpVKJJUuWwMhIJO5t37490/Hs7e1x5coVjbawsDCYmJgAAKpVqwYzMzNERESgRYsWWc6PiIiIiIhIRW4kR4MyDTLu8NtvQGgoYG0NTJuWfxOjPGfwpWSplShRApUqVcKdO3fg5OSExMTEdIGAZ8+ewcnJCYDYqjztzmCqr7PqY2trCwsLC5QuXRpyuVxrn9RjZDUXbczMzGBra6txyzOmVu9vqQJBppYp7XkoIiIC48ePx82bN/Hrr79ixYoVGDt2bKaPmTx5Mk6dOoVRo0YhLCwMt2/fxh9//KEuPl25cmW0b98en3/+Oc6cOYPQ0FAMGzYs04Bh37594eTkhK5du+LkyZO4d+8efvvtN/VyP3d3d4SHhyMsLAwvX75EQkIC2rZtCy8vL3Tt2hV///037t+/j1OnTuHrr7/G+fPnAQBjx47Fhg0bsHHjRty6dQuzZs1SL1XMjLu7O5o0aYKhQ4dCoVDgk08+UZ+rUKECkpKSsGLFCty7dw+//PKLRuBIm9atW+P8+fP4+eefcfv2bcyaNUsjUGRjY4MJEyZg3Lhx2LRpE+7evYsLFy5gxYoV2LRpU5bzJSIiIiIi0iopCfj6a3E8YQJgb2/Y+ZBeFajAUExMDO7evQtnZ2fUq1cPJiYmOHjwoPr8zZs3ERERoa7v4uXlhcuXL2vsVLV//37Y2tqiWrVq6j6px1D1UY1hamqKevXqafRRKpU4ePCguo8ucynOBgwYgHfv3qFhw4bw8/PD2LFj1VvSZ6RWrVo4evQobt26BW9vb9SpUwczZ86Ei0tKPaSNGzfCxcUFLVq0gK+vL0aMGAEHB4cMxzQ1NcXff/8NBwcHfPzxx6hZsyYWLFigzlzq3r072rdvj1atWsHe3h6//vorZDIZ/vzzTzRv3hyDBw9GpUqV0KdPHzx48EC9vLB3796YMWMGJk2ahHr16uHBgwcYOXKkTj+b/v3749KlS+jWrZtGUKt27dpYunQpFi5ciBo1amDz5s0ICAjIdCwfHx/1PBo0aIC3b99qZDEBwLx58zBjxgwEBASgatWqaN++PUJCQuDh4aHTfImIiIiIqHhKVCTiu5Pf4buT3yFRkah5MigIuH1bBIRSrYqhokEmpS1ako8mTJiAzp07o1y5cnjy5AlmzZqFsLAwXLt2Dfb29hg5ciT+/PNPBAUFwdbWFqNHjwYAnDp1CoDYrt7T0xMuLi5YtGgRIiMj8dlnn2HYsGGYP38+ALFdfY0aNeDn54chQ4bg0KFDGDNmDEJCQuDj4wNAbFc/cOBArFu3Dg0bNkRgYCC2b9+OGzduqIMDWc1FF9HR0bCzs0NUVFS67KH4+HiEh4fDw8MD5uZa1nMWUC1btoSnpycCAwMNPRXKgcL6vCMiIiIiogwoFMDx48DTp4CzM+DtrdM28rGJsbAOsAYAxEyNgZVq5cm7d0CFCsCTJ8CyZYCWOrFUMGUWg0jNoDWGHj16hL59++LVq1ewt7dHs2bN8M8//8D+fVra999/DyMjI3Tv3h0JCQnw8fHB6tWr1Y+Xy+XYs2cPRo4cCS8vL1hZWWHgwIGYO3euuo+HhwdCQkIwbtw4LFu2DK6urli/fr06KASIjJAXL15g5syZiIyMhKenJ/bu3atRkDqruRAREREREREZVHAwMHYs8OhRSpurqwjo+PrmbMyVK0VQqFw54PPP9TNPKlAMmjFU3DBjiAqawvq8IyIiIiKiNIKDgR49gLQf8WUycb9zZ6bBIa0ZQ2/eAB9+CLx+DWzaBKQpZUEFW6HIGKLCT9s270RERERERJSPFAqRKaQt70OSRHDI3x/o0kWnZWVq330ngkLVqwP9++ttulSwFKji00RERERERESUTcePay4fS0uSgIcPRT9dPX0KqFaGzJ+fvYASFSoMDBUwXNlH+YnPNyIiIiKiIuDpU/32A4BvvgHi4gAvL6Bz55zNiwoFBoYKCBMTEwBAXFycgWdCxUliotiGUs7oPxERERFR4eXsrN9+4feAH34QxwsWpNQpoiKJNYYKCLlcjhIlSuD58+cAAEtLS8j44qM8pFQq8eLFC1haWsLYmG8FRERERESFlre32H3s8WPtdYZkMnHe2zvDIcyNzXF44GFxPO1bIDkZ6NABaN484+smxgLzXcTxtCeAaot7KlT4abAAcXJyAgB1cIgorxkZGaFs2bIMQhIRERERFWZyudiSvkeP9OdU/9cPDMy0TpBcAlreB3D6NPDrNtE4f76+Z0oFEANDBYhMJoOzszMcHByQlJRk6OlQMWBqagojI64oJSIiIiIq9Hx9xZb0/foBCQkp7a6uIiiUyVb1CA4Wu5qlLmBtYQHcuwd4eqbvnxj7/j5VKZTUx8wcKlRkEqvP5pvo6GjY2dkhKioKtra2hp4OERERERERFSVJSYCdHfDuHbBoEdCggVg+lllN0eBgoEcPJMkk/FBPNI0IBUyk95lGO3emDyrNtst8HrOjcv49kN7oGoNgxhARERERERFRUXDpkggKlSgBfPUVkNXqAIVCZApJEhKNgVEdRfOgMMAkSRLL0Pz9gS5duF19EcbAEBEREREREVFRcOKEuG/SJOugEAAcP665fCwtSQIePhT9WrZMaZ/2RNwnxgGLK4jjCXcAU8scTZsMi4EhIiIiIiIioqLg5Elx36yZbv2fPs1ZP201hEwtWVuokGLVWSIiIiIiIqLCTpJSAkNNm+r2GGdn/fajQokZQ0RERERERESFXXi4yOwxMRFFp3Xh7S12LXv8GICWfalkMnHe21v7402tWGi6CGDGEBEREREREVFhp8oWqldPbDWvC7kcWLZMHMvSnJO9bwgMZOHpIo6BISIiIiIiIqLCLrvLyFR8fcWW9C4umu2urtq3qqcih0vJiIiIiIiIiAo71Y5k2Q0MAYCvL8w6d8Se3UuB/17DbJ8P0LwlM4WKCZkkSVoWElJeiI6Ohp2dHaKiomBra2vo6RAREREREVFR8Po1ULKkOH72DHBwMOx8qEDQNQbBpWREREREREREhdnp0+K+YkUGhSjbuJSMiIiIiIiIqDBTLSNr1izHQyQpkrD58mYAQP+a/WEiN9HHzKgQYGCIiIiIiIiIqDDLaeHpVBIViRj8x2AAQM9qPRkYKka4lIyIiIiIiIiosEpMBM6eFce5CAxR8cWMISIiIiIiIioYFArg+HHg6VPA2Rnw9ubOWFm5cAGIjwdKlQIqVzb0bKgQYmCIiIiIiIiIDC84GBg7Fnj0KKXN1RVYtgzw9TXcvAq61MvIZDLDzoUKJS4lIyIiIiIiIsMKDgZ69NAMCgHA48eiPTjYMPMqDFSFp7mMjHKIgSEiIiIiIiIyHIVCZApJUvpzqjZ/f9GPNElSSsZQLnYko+KNgSEiIiIiIiIynOPH02cKpSZJwMOHoh9punMHePECMDMD6tXL3ViJsdqPqchjjSEiIiIiIiIynKdP9duvOFEtI6tfXwSHcsHM2AzbJQv1MRUfDAwRERERERGR4Tg767dfcaKPZWTvs4OMkxPREyaiLTkxJWvI1CoXE6TCgIEhIiIiIiIiMhxvb7H72OPH2usMyWTivLd3/s+toEu9I1lOzXdJ37a4Qsrx7Kicj02FQoGpMbRgwQLIZDL4+/ur2+Lj4+Hn54dSpUrB2toa3bt3x7NnzzQeFxERgY4dO8LS0hIODg6YOHEikpOTNfocOXIEdevWhZmZGSpUqICgoKB011+1ahXc3d1hbm6ORo0a4ezZsxrndZkLERERERERZZNcLrakz0xgoOhHKV6+BG7cEMdNmuR6uGRI2IEk7EASkqElQEdFVoEIDJ07dw7r1q1DrVq1NNrHjRuH//u//8OOHTtw9OhRPHnyBL6+vurzCoUCHTt2RGJiIk6dOoVNmzYhKCgIM2fOVPcJDw9Hx44d0apVK4SFhcHf3x/Dhg3Dvn371H22bduG8ePHY9asWbhw4QJq164NHx8fPH/+XOe5EBERERERUQ75+gItW2o/N2eOOE+aTp0S91WrAqVK5XycaU+AaU+QMPZf9JK9Qy/ZOySM/VfdTkWfwQNDMTEx6N+/P3788Ud88MEH6vaoqCj89NNPWLp0KVq3bo169eph48aNOHXqFP755x8AwN9//41r167hf//7Hzw9PdGhQwfMmzcPq1atQmJiIgBg7dq18PDwwJIlS1C1alWMGjUKPXr0wPfff6++1tKlSzF8+HAMHjwY1apVw9q1a2FpaYkNGzboPBciIiIiIiLKoRcvUgIdK1YAW7YAnTuLry9dMty8CjJ9LCMDRA0hUyvAxDKlzcQypZ2KPIMHhvz8/NCxY0e0bdtWoz00NBRJSUka7VWqVEHZsmVx+vRpAMDp06dRs2ZNODo6qvv4+PggOjoaV69eVfdJO7aPj496jMTERISGhmr0MTIyQtu2bdV9dJmLNgkJCYiOjta4ERERERERURrr1gEJCWJ3LT8/oG9fICBAnPv9dyAiwrDzK4hUO5LlpvA0EQwcGNq6dSsuXLiAANULPpXIyEiYmpqiRIkSGu2Ojo6IjIxU90kdFFKdV53LrE90dDTevXuHly9fQqFQaO2Teoys5qJNQEAA7Ozs1Dc3N7cM+xIRERERERVLiYnA6tXi2N9fFJsGgOrVgdatAaUSWLPGYNMrkOLjgfPnxXFuM4ZUUmcHMVOoWDFYYOjhw4cYO3YsNm/eDHNzc0NNI09NnToVUVFR6tvDhw8NPSUiIiIiIqKCZccO4OlTsR19z56a50aPFvc//gi8e5f/cyuoQkNFQM3BAShf3tCzoULOYIGh0NBQPH/+HHXr1oWxsTGMjY1x9OhRLF++HMbGxnB0dERiYiLevHmj8bhnz57ByckJAODk5JRuZzDV11n1sbW1hYWFBUqXLg25XK61T+oxspqLNmZmZrC1tdW4ERERERER0XuSlLIj2ciRgKmp5vnOnYFy5YBXr4CtW/N/fgVV6mVkqgwrohwyWGCoTZs2uHz5MsLCwtS3+vXro3///upjExMTHDx4UP2YmzdvIiIiAl5eXgAALy8vXL58WWP3sP3798PW1hbVqlVT90k9hqqPagxTU1PUq1dPo49SqcTBgwfVferVq5flXIiIiIiIiCib/vkHOHdOBIQ+/zz9ebkc+PJLcbxihQgkkf4KTxMBMDbUhW1sbFCjRg2NNisrK5QqVUrdPnToUIwfPx4lS5aEra0tRo8eDS8vLzRu3BgA0K5dO1SrVg2fffYZFi1ahMjISEyfPh1+fn4wMzMDAHzxxRdYuXIlJk2ahCFDhuDQoUPYvn07QkJC1NcdP348Bg4ciPr166Nhw4YIDAxEbGwsBg8eDACws7PLci5ERERERESUTapsoX79xLIobYYOBWbNAi5eFAGR4l5sWanMk8CQqdwUG7tsVB9T8WGwwJAuvv/+exgZGaF79+5ISEiAj48PVquKkgGQy+XYs2cPRo4cCS8vL1hZWWHgwIGYO3euuo+HhwdCQkIwbtw4LFu2DK6urli/fj18fHzUfXr37o0XL15g5syZiIyMhKenJ/bu3atRkDqruRAREREREVE2PHoE7NwpjseOzbhfqVLAp58C69eLrCFDBoYUCuD48ZSaSN7eIqspP928Cfz3H2BhAdSpo7dhTeQmGOQ5SG/jUeEhkyTm4uWX6Oho2NnZISoqivWGiIiIiIioeJs2TWxJ37w5cPRo5n3//ReoXVsEYR48AMqUyZ85phYcLAJYjx6ltLm6iqwnX9/8m8f69cDw4UCLFsCRI/l3XSp0dI1BGHS7eiIiIiIiIiqG4uKAH34Qx/7+WfevVUsEkBQKYO3aPJ2aVsHBQI8emkEhAHj8WLQHB+ffXFSFp/VcXyhZmYyQWyEIuRWCZGWyXsemgo2BISIiIiIiIspfmzeLncbc3YFPPtHtMaqt69etAxIS8mxq6SgUIlNI22IbVZu/v+iXH1T1hfS8pC4hOQGdfu2ETr92QkJyPv58yeAYGCIiIiIiIqL8k3qL+lGjdK/R07WrWLr14gWwbVueTS+d48fTZwqlJknAw4eiX1579gy4c0dsUc8dsklPGBgiIiIiIiKi/HPoEHD1KmBlJXYc05WxsWG2rn/6VL/9ckOVLVSjBlCiRN5fj4oFBoaIiIiIiIgo/6iyhQYOzH5wY/hwwMwMOH8eOHNG71PTytlZv/1yIw+2qSdiYIiIiIiIiIjyx927wJ494njMmOw/vnRpoG9fcbxihf7mlRlvb7GETSbTfl4mA9zcRL+8xsAQ5QEGhoiIiIiIiCh/qJaAtW8PVK6cszFURah37Mif5VtyeUqWU1qqYFFgoO61knIqLg4IDRXHei48TcUbA0NERERERESU96KjgQ0bxLEuW9RnpG5doEkTIClJ7FCWH3x9gZ07AXNzzfZSpUS7r2/ez+HcOSA5GXBxAcqVy/vrUbHBwBARERERERHlvaAg4O1boEoVoF273I2lWoa2bh2QmJjrqemkSxdR3wgQS8sA4PPP8ycoBGguI8toWVsumMpNsbLDSqzssBKmclO9j08FFwNDRERERERElLcUCmD5cnE8ZkzuAxu+viJzJjJSZOzkh8uXgagowMYGmDRJtJ07lz/XBoATJ8R9Hi0jM5GbwK+hH/wa+sFEbpIn16CCiYEhIiIiIiIiylt//ikKT5coAQwYkPvxTEyAL74Qx/lVhProUXHftKlYygYAZ88CSmXeX1upBE6fTrk+kR4xMERERERERER5S1W8edgwwMpKP2OOGAGYmgL//JM/mTuqwFCLFkCtWqLe0Js3wO3beX/ta9fEtaysgNq18+QSCqUCR+4fwZH7R6BQKvLkGlQwMTBERERERERE+qdQAEeOAIsWAQcPiuVjo0bpb3xHR6BXL3Gc11lDSiVw7Jg4btFCZCzVrSu+PnMmb68NpCwja9wYMDbOk0vEJ8ej1aZWaLWpFeKT4/PkGlQwMTBERERERERE+hUcDLi7A61aAZMnizZz85Tt1vVFtXX9tm3A8+f6HTu1a9eAV68AS0ugXj3R1qiRuM+PwFDqwtNEesbAEBEREREREelPcDDQowfw6JFm+7t3oj04WH/XathQBGgSE4GpU4FffxVZSgo9L4VSZQt5eYnlawADQ1Rk5DgwlJycjAMHDmDdunV4+/YtAODJkyeIiYnR2+SIiIiIiIioEFEogLFjAUnKuI+/v34DN40bi/sNG4B+/USWkru7fgNQqesLqagCQ5cuiaBXXnnyBAgPB4yMUr5XIj3KUWDowYMHqFmzJrp06QI/Pz+8ePECALBw4UJMmDBBrxMkIiIiIiKiQuL48fSZQqlJEvDwoeinD8HBwPLl6dsfP9ZfdpIkaQ8MlSsHODgAycnAxYu5v05GVNlCtWoBtrZ5dx0qtnIUGBo7dizq16+P169fw8LCQt3erVs3HDx4UG+TIyIiIiIiokLk6VP99stMZtlJqjZ9ZCfdugU8ewaYmYmlayoyWd4uJ1MV7/7pJ/F1kyb6vwYRchgYOn78OKZPnw5T1drK99zd3fH48WO9TIyIiIiIiIgKmdevdevn7Jz7a+VXdpIqW6hxY1FAO7W8CgylLt69b59o27pVv8vjiN7L0T53SqUSCi1R10ePHsHGxibXkyIiIiIiIqJC5N07YOZMYMmSzPvJZICrK+Dtnftr5ld2krZlZCp5ERhSFe9Omwn1+rVo37kT8PXV3/XeM5GbYFHbRepjKj5ylDHUrl07BAYGqr+WyWSIiYnBrFmz8PHHH+trbkRERERERFTQnT4N1KkDLF4sghktWogAkEym2U/1dWAgIJfn/rq6Zh3lJjspo/pCKvXri/v794Hnz3N+HZX8Wh6nhancFBObTsTEphNhKjfN+gFUZOQoMLRkyRKcPHkS1apVQ3x8PPr166deRrZw4UJ9z5GIiIiIiIgMRVXrJu1W8O/eARMnAs2aATdvAk5OwO7dos/OnUCZMprjuLrqN9vF21uMmTYApSKTAW5uuctOundPFLI2MdG+I1iJEkCVKuL47NmcX0clv4t3EyGHS8lcXV1x6dIlbN26Ff/++y9iYmIwdOhQ9O/fX6MYNRERERERERViwcEigyV1sMLVFfjyS2DTJhEQAoABA4DvvwdKlhRf+/oCXbqIAMbTpyJrx9tbP5lCKnI5sGyZWF4lk2nPssltdpIqW6hhQ8DSUnufRo2AGzfEcrJOnXJ+LSB/i3enoVAqcOHpBQBAXee6kBvp8XdFBVqOAkMAYGxsjE8//VSfcyEiIiIiIqKCIqNaN48eAdOmiWNnZ+CHH7QHRORyoGXLvJ2jr6/IQkobvAKAVatyn52kCgw1b55xn0aNRJBMH3WG8mN5XAbik+PRcL3YdS1magysTK30fg0qmHQODO3evVvnQT/55JMcTYaIiIiIiIgKgMxq3ahYWgL//guULp1/89ImbXbSkiVAaCjw5Enux86svpCKqgD12bOAUgkY5ahii6BaHvf4sfafvT6LdxO9p3NgqGvXrjr1k8lkWncsIyIiIiIiokIiq1o3ABAXB1y5kvdZQbpInZ1kZAT06QMEBQGzZ+d8KdmDB+ImlwNNmmTcr2ZNsY19VBRw61ZKzaGcSL08Li19F+8mek/nUKZSqdTpxqAQERERERFRIWfAWje51rWrqHX06BHw9985H+fYMXFfrx5gY5NxPxMT0QfQz3IyX19g27b0RbX1Xbyb6L1c5LgRERERERFRkWTAWje5ZmYGfPaZOF6/Pufj6LKMTEW1nEwfgSEAcHERS8msrYFffgEOHwbCwxkUojyR48BQbGws/vzzT6xduxbLly/XuOlqzZo1qFWrFmxtbWFrawsvLy/89ddf6vPx8fHw8/NDqVKlYG1tje7du+PZs2caY0RERKBjx46wtLSEg4MDJk6ciOTkZI0+R44cQd26dWFmZoYKFSogKCgo3VxWrVoFd3d3mJubo1GjRjibZqtBXeZCRERERERUJHh7i63YM6KPreDz0tCh4n73buD585yNYcjAUEiIuO/cGfj0U7FMjsvHKI/kaFeyixcv4uOPP0ZcXBxiY2NRsmRJvHz5Uh2cGTNmjE7juLq6YsGCBahYsSIkScKmTZvQpUsXXLx4EdWrV8e4ceMQEhKCHTt2wM7ODqNGjYKvry9OnjwJAFAoFOjYsSOcnJxw6tQpPH36FAMGDICJiQnmz58PAAgPD0fHjh3xxRdfYPPmzTh48CCGDRsGZ2dn+Pj4AAC2bduG8ePHY+3atWjUqBECAwPh4+ODmzdvwsHBAQCynAsREREREVGRsXkz8OaN9nOFodZNzZpii/mzZ0XGzVdfZe/xT54Ad+6IekXNmmXdXxUY+vdf4N07wMIi+3NO7c8/xf3HH+duHCJdSDnQokULafjw4ZJCoZCsra2lu3fvShEREVLz5s2l3377LSdDqn3wwQfS+vXrpTdv3kgmJibSjh071OeuX78uAZBOnz4tSZIk/fnnn5KRkZEUGRmp7rNmzRrJ1tZWSkhIkCRJkiZNmiRVr15d4xq9e/eWfHx81F83bNhQ8vPzU3+tUCgkFxcXKSAgQJIkSae56CIqKkoCIEVFRen8GCIiIiIiony1fbskGRlJEiBJHTpIkqurOFbd3NwkKZef+/LFunVivlWqSJJSmb3HbtkiHlu3rm79lUpJcnQUjzlxIvtzTe3RIzGOTCZJL17kbqxsSEhOkGYdniXNOjxLSkhOyLfrUt7RNQaRo6VkYWFh+Oqrr2BkZAS5XI6EhAS4ublh0aJFmDZtWo4CVAqFAlu3bkVsbCy8vLwQGhqKpKQktG3bVt2nSpUqKFu2LE6fPg0AOH36NGrWrAlHR0d1Hx8fH0RHR+Pq1avqPqnHUPVRjZGYmIjQ0FCNPkZGRmjbtq26jy5zISIiIiIiKvRCQoB+/cS260OGAHv2APfvixo3W7YUrlo3ffoAlpbAjRtAdj+3ZWcZGSCyqPS1nEyVLdSoEVC6dLYfHpeYDPcpIXCfEoK4xOSsH/CeqdwUs1vOxuyWs2EqN832danwylFgyMTEBEZG4qEODg6IiIgAANjZ2eHhw4fZGuvy5cuwtraGmZkZvvjiC/z++++oVq0aIiMjYWpqihJp1rU6OjoiMjISABAZGakRFFKdV53LrE90dDTevXuHly9fQqFQaO2Teoys5qJNQkICoqOjNW5EREREREQF0sGDQPfuQHKyCKr88INYSqXaCr5v38JV68bWFujVSxxntwi1KjDUvLnuj9F3YKhjx9yNQ6SjHAWG6tSpg3PnzgEAWrRogZkzZ2Lz5s3w9/dHjRo1sjVW5cqVERYWhjNnzmDkyJEYOHAgrl27lpNpFTgBAQGws7NT39zc3Aw9JSIiIiIiovROngQ++QRISAC6dAF+/rnwBIAyoypCvX078Patbo959kxkGQHZK66tj8BQQgKwf784zmZ9objE5Pc3Rao2hbo9K0pJiavPr+Lq86tQSspsXZsKtxwVn54/fz7evn9RffvttxgwYABGjhyJSpUqYX02I7GmpqaoUKECAKBevXo4d+4cli1bht69eyMxMRFv3rzRyNR59uwZnJycAABOTk7pdg9T7RSWuk/a3cOePXsGW1tbWFhYQC6XQy6Xa+2Teoys5qLN1KlTMX78ePXX0dHRDA4REREREVHBEhoqghBxcUC7dsC2bYCJiaFnpR9NmwKVKwM3b4rva9iwrB9z7Ji4r1kTKFVK92s1aCCWlD14IIJLaVal6OT4cSA2FnByAjw9s/XQajP3pWur/80B9fH9BZlnIL1Leocaa0SiR8zUGFiZWmXr+lR45ShjqHr16mj0Phrq4OCAtWvXYs6cOfj222/hmc0nb1pKpRIJCQmoV68eTExMcPDgQfW5mzdvIiIiAl5eXgAALy8vXL58Gc9TbT+4f/9+2Nraolq1auo+qcdQ9VGNYWpqinr16mn0USqVOHjwoLqPLnPRxszMDLa2tho3IiIiIiIig1EogCNHgF9/FfeXLolgUHS0yI75/XfAzMzQs9QfmSwla0jXJIbs1hdSsbUFqlYVx2kSGHSm2qb+44/FMr58lDqrKDu1iajwy1HGUJcuXeDr64svvvgCb968QePGjWFiYoKXL19i6dKlGDlypE7jTJ06FR06dEDZsmXx9u1bbNmyBUeOHMG+fftgZ2eHoUOHYvz48ShZsiRsbW0xevRoeHl5oXHjxgCAdu3aoVq1avjss8+waNEiREZGYvr06fDz84PZ+zezL774AitXrsSkSZMwZMgQHDp0CNu3b0eI6gUHYPz48Rg4cCDq16+Phg0bIjAwELGxsRg8eDAA6DQXIiIiIiKiAi04GBg7Fnj0KKXNyEgUmm7QQBSatrQ03PzyyoABwLRpYonX1atA9eqZ91dlDGU3MAQADRsC166Ja3XunP3H52Kb+mtzfQCI5WOqTKHz09vC0rQILAmkPJWjEOSFCxfg/X6t5c6dO+Ho6IgHDx7g559/xvLly3Ue5/nz5xgwYAAqV66MNm3a4Ny5c9i3bx8++ugjAMD333+PTp06oXv37mjevDmcnJwQHBysfrxcLseePXsgl8vh5eWFTz/9FAMGDMDcuXPVfTw8PBASEoL9+/ejdu3aWLJkCdavXw8fHx91n969e2Px4sWYOXMmPD09ERYWhr1792oUpM5qLkRERERERAVWcDDQo4dmUAgQQSEA8PMTGS9FkaNjSpDmp58y7/vqFXD5sjjOTuFpldzUGbpzB7h1CzA2Bt5/Js4OS1Pj9zd5qja5uj0j6tpESalqEyXpXpuICj+ZJElSdh9kaWmJGzduoGzZsujVqxeqV6+OWbNm4eHDh6hcuTLi4uLyYq6FXnR0NOzs7BAVFcVlZURERERElD8UCsDdPX1QSEUmA1xdxTb0RaHgtDYhIUCnTqJm0OPHGS+X27UL6NZNLAnLyaZIFy8CdeuKINvr19lbDrZ8ucjoatUKOHQo+9d+Ly4xWV1v6Npcn0yDQgDgPkWsplEiHg8tegAA3N7thBHMAWRdm4gKLl1jEDnKGKpQoQJ27dqFhw8fYt++fWjXrh0AkQHEgAcREREREVEBcvx4xkEhAJAk4OFD0a+o8vEBypQRGUG7d2fcL6f1hVRq1gQsLETNpps3s/dYPW1Tb2lqjPsLOuL+go5ZBoWIgBwGhmbOnIkJEybA3d0djRo1Uhdg/vvvv1GnTh29TpCIiIiIiIhy4elT/fYrjIyNgUGDxHFmy8lyGxgyNgbq1RPH2VlOFhsrioEDOaovlBvX5vrg2lwfHJ/cSt12fHIrdTsVfTkKDPXo0QMRERE4f/489u7dq25v06YNvv/+e71NjoiIiIiIiHLJ2Vm//QqrIUPE/d9/iy3l03rzBggLE8c5qS+kkpM6Q4cOAQkJYslflSo5v3YOqGoQ2ZmbwzbJF7ZJvrAzN8+yNhEVHTne/87JyQl16tSBUao1kw0bNkSVfH4SExERERERUSayWtIkkwFubmK7+qLsww+B1q3F0rmgoPTnT5wQ5ypUAFxccn6dnASGVLtmd+wofh8GYCo3xQfJQ/BB8hCYyk0NMgcyjBwHhoiIiIiIiKgAUyrFNu1ffJHSljbooPo6MLDoFp5ObehQcb9hgyjKnVpul5GpqAJD//4L6LIxkyTlapt6fWFtouKLgSEiIiIiIqKiJj4e6N8fCAgQX8+aBezcKQowp+bqKtp9ffN/jlrEJSbDfUoI3KeE5M1W6d26ASVKABERwMGDmuf0FRhycwOcnETg6cKFrPtfvSqKf5ubix3JDEQpKXH/zX3cf3MfSklpsHlQ/mNgiIiIiIiIqCh59Qr46CNg61ZRDDkoCJg9G+jeHbh/Hzh8GNiyRdyHhxeYoFC+sLAAPv1UHKcuQv32bUoQJ7eBIZkse8vJVMvIWrcW8zOQd0nv4LHMAx7LPPAu6Z3B5kH5j4EhIiIiIiKiouLuXcDLS9TLsbMD9u4FBg5MOS+XAy1bAn37ivsCsnwsLjH5/U2Rqk2hbtcr1XKy338HXr4UxydPigwfd3egbNncXyM7gSE9bVNPlFNcOEhERERERFTYKBTA8eNii3lnZ1E4+uxZ4JNPRLCjbFkRcKhe3dAz1Um1mfvStdX/5oD6+P4CPQZNPD3FlvKhocD//gf4+wPHjolzuc0WUtE1MPT6tQhKAUCHDvq5NlE2MWOIiIiIiIioMAkOFpktrVoB/fqJe0dHEdR4+RKoWxf4559CExQyCFXW0E8/ieLP+qovpFK/vlhSFhEBREZm3G//fhHkq1oV8PDQz7WJsokZQ0RERERERIVFcDDQo4cIZqT26pW4r1tXBDmsrfN/brlwba4PALF8TJUpdH56W1ia5tFSt759gfHjgStXxI5sqsyeZs30M76tLVCtmigsfeYM0KWL9n6pt6knMhBmDBERERERERUGCgUwdmz6oFBqz58btIBxTlmaGr+/yVO1ydXteleiRMpyr/HjU7aub91aBN/0QTX+2bPazyuVwF9/iWMDblNPxMAQERERERFRYXD8OPDoUeZ9Hj0S/ShzwcEpy8dSe/xYZGTpIziUVZ2h0FDgxQvAxkZ/mUpEOcClZERERERERIXB06f67VcAWZoa67fQtDaqzCttJEnUBvL3F8u/crNrW8OG4v7cOZEdZJQmL0O1jKxdO8DEJOfX0RNjI2N8Wf9L9TEVH/xtExERERERFQbOzvrtV1xllXklScDDh6Jfy5Y5v06NGoClJRAdDdy4IWoOpVbAtqk3MzbDqo6rDD0NMgAuJSMiIiIiIioMvL0zD/rIZICbm+hHGctF5lVcYjLcp4TAfUoI4hKTM3+8sTFQr544Truc7NkzkUkEAO3b6zYfojzCwBAREREREVFhoFCIejTayGTiPjAwd8ufioP8zLzKqM7Q3r3ivm7dApPhJUkSXsS+wIvYF5AyK3BORQ4DQ0RERERERIXBpEnArVtieZKTk+Y5V1dg507A19cwcytMvL3Fz0sVTEtLS+ZVXGLy+5siVZtC3Z6hjAJDBXCb+rikODgsdoDDYgfEJcUZejqUj1hjiIiIiIiIqKDbsQNYtkwc//qrCCgcPy6WOzk7iyAGM4V0I5eLn2WPHiIIlDo7JoPMq2oz96Ubpv43B9THGRbMVgWGLl8G4uJEUC8pCfj7b9HObeqpAGDGEBERERERUUF28yYwZIg4njwZ+OQTEbRo2RLo21fcMyiUPb6+IsOqTBnNdn1nXrm6isCdQiG2pweA06eBqCigdGmgQQP9XIcoF5gxREREREREVFDFxgLduwMxMUCLFsA33xh6RkWHr6/Ykl6HzKtrc30AiOVjqkyh89PbwtI0i4CcTCayhnbtEsvJvL1TlpG1b8+AHhUIDAwREREREREVRJIEjBwJXL0qagpt3Sp2uiL9UWVeZcHSNP3P3dJUrrU9ndSBISBlm3ouI6MCgkvJiIiIiIiICqIffwR++UUEL7ZtS19wuoDL1tbuRVnqAtQREcCVK4CREeDjY9h5Eb3HcDMREREREVFBExoKjB4tjufPB5o3N+x8Cri4xGR1gehrc310y+TJAUtT44wLTWekfn2xpOzhQ+Cnn0SblxdQsqT+J0iUAwwMERERERGRKI7LXa4KhtevxY5ZiYmiBs7EiYaeUbaosoPSbu2ukldBmwLLxgaoVk0sCfzuO9HWoYNh56SFsZExBtYeqD6m4oO/bSIiIiKi4i44GBg7Fnj0KKXN1VVs6a2v3ZlIN0olMGAAcP8+8OGHQFBQyhbqhUSOt3bPgUIRhAoOFr9PAHj3TtyvWAFUrZrp6yu/sqBUzIzNENQ1KE+vQQVTAXiVEBERERGRwQQHi+wUSdJsf/xYtOtz625KL22m1smTwJ49gJmZ+NmXKGHoGRZo+RmEypGMXl/Pn/P1RQUGA0NERERERMWVQiEyhdJ+aAVEm0wG+PuL5UxcVqZ/2jK1VFauBOrUyf85aZHdzJUcb+1e1OTw9WWoLChJkhCXFCeuYWIJWSHLVKOcY2CIiIiIiKi4On5ce1BCRZJEwdzjx3Xa0puyIaNMEpUPPsjf+ehRrrZ2z6YCHYTK4evLUFlQcUlxsA6wBgDETI2BlalVnlyHCh6DblcfEBCABg0awMbGBg4ODujatStu3ryp0Sc+Ph5+fn4oVaoUrK2t0b17dzx79kyjT0REBDp27AhLS0s4ODhg4sSJSE7W3A7xyJEjqFu3LszMzFChQgUEBQWlm8+qVavg7u4Oc3NzNGrUCGfPns32XIiIiIiICo2nT/Xbr7hTKIAjR4BffxX3CkXG/TLKJAFEJsm4cRk/Pp/EJSa/v2lmrqjaCwJLU+P3N3mqNrm63aD4+qJCwqCvlKNHj8LPzw8NGjRAcnIypk2bhnbt2uHatWuwshLRyXHjxiEkJAQ7duyAnZ0dRo0aBV9fX5w8eRIAoFAo0LFjRzg5OeHUqVN4+vQpBgwYABMTE8yfPx8AEB4ejo4dO+KLL77A5s2bcfDgQQwbNgzOzs7w8RER5m3btmH8+PFYu3YtGjVqhMDAQPj4+ODmzZtwcHDQaS5ERERERIWKs7N++xVn2SngXUgytXKbuZKjrd2Lkhy+vgp0FhQVSTJJyihMnf9evHgBBwcHHD16FM2bN0dUVBTs7e2xZcsW9OjRAwBw48YNVK1aFadPn0bjxo3x119/oVOnTnjy5AkcHR0BAGvXrsXkyZPx4sULmJqaYvLkyQgJCcGVK1fU1+rTpw/evHmDvXv3AgAaNWqEBg0aYOXKlQAApVIJNzc3jB49GlOmTNFpLlmJjo6GnZ0doqKiYGtrq9efHRERERFRtikUgLt7xkEKmUwEN8LDWWMoMxktC1PVaNm5E2jeHDhxQgR7fv9d/EyzsmUL0Lev/uerI/cpIZmeL9ZBH12oXl+PH2vPDsvi9ZXfu5LFJsZyKVkRo2sMwqBLydKKiooCAJQsWRIAEBoaiqSkJLRt21bdp0qVKihbtixOnz4NADh9+jRq1qypDgoBgI+PD6Kjo3H16lV1n9RjqPqoxkhMTERoaKhGHyMjI7Rt21bdR5e5EBFRIaNryj8RUVEllwOjR2feJzCQQaHMZFVgWJKA3r0Be3ugWzdg6VLdgkKAwTO1rs31wbW5Pjg/PeUz0PnpbdXtlAW5XGSMASlBQhXV13x9UQFQYIpPK5VK+Pv7o2nTpqhRowYAIDIyEqampiiRZotGR0dHREZGqvukDgqpzqvOZdYnOjoa7969w+vXr6FQKLT2uXHjhs5zSSshIQEJCQnqr6Ojo7P6MRARUX7JTso/EVFRpVQCu3aJY0tLIC5O8/yoUQXnPTHttu7e3gXjA3VWy8IAQFX/tFo1Me+mTYHJk4HIyMwzSby99T/fbMjPItJFlq+vyBjT9n+OwMBMX1/Ffike5ZsC84r28/PDlStXcOLECUNPRW8CAgIwZ84cQ0+DiIjSyijl//Fj0b5zZ8H5IERElJc2bwZOnwasrIDr14G7d0Xg5cgR4IcfgD//BJYsAUxMDDvPghzM17Vw8Lp1wIgRKV9bWYl/c2QyzX+PmElS9Pj6ii3pC2JgkwgFZCnZqFGjsGfPHhw+fBiurq7qdicnJyQmJuLNmzca/Z89ewYnJyd1n7Q7g6m+zqqPra0tLCwsULp0acjlcq19Uo+R1VzSmjp1KqKiotS3hw8f6vDTICKiPJVVyj8A+PtzWRkRFX1v3wKTJonjGTMANzdR6LhvX7Hcyd5eBIp++cWg01QH89Nm5aiC+cHBhpmXiq7LvSpV0vxalUlSpoxmu6trnv6BIi4xGe5TQuA+JUTnncVUmSv3F3RktlBOyeUpr6+WLQtkUEhuJEePaj3Qo1oPyI0K3vwo7xg0MCRJEkaNGoXff/8dhw4dgoeHh8b5evXqwcTEBAcPHlS33bx5ExEREfDy8gIAeHl54fLly3j+/Lm6z/79+2Fra4tq1aqp+6QeQ9VHNYapqSnq1aun0UepVOLgwYPqPrrMJS0zMzPY2tpq3IiIyMCysxMMEVFRNm+eWMpUoYIIiKdmZQVMmZLSLzEx36cHoHAE8z08AONMgiUymQi6aVsW5usL3L8PHD4sCk0fPizqDxk6C4qKJXNjc+zouQM7eu6AubG5oadD+cig4V4/Pz9s2bIFf/zxB2xsbNS1euzs7GBhYQE7OzsMHToU48ePR8mSJWFra4vRo0fDy8tLvQtYu3btUK1aNXz22WdYtGgRIiMjMX36dPj5+cHMzAwA8MUXX2DlypWYNGkShgwZgkOHDmH79u0ICUmpsj9+/HgMHDgQ9evXR8OGDREYGIjY2FgMHjxYPaes5kJERIWArin/uvYjIiqMbt4US5UAcf/+/80avvgC+O47EbgICtJcBpVfCvq27rduAe3apdQQysmyMFUmSR5TZQfFJSpStaUcMxOIqPgy6Kt/zZo1AICWad4IN27ciEGDBgEAvv/+exgZGaF79+5ISEiAj48PVq9ere4rl8uxZ88ejBw5El5eXrCyssLAgQMxd+5cdR8PDw+EhIRg3LhxWLZsGVxdXbF+/Xr4+KRU0u/duzdevHiBmTNnIjIyEp6enti7d69GQeqs5kJERIWArin/Bt4Jhogoz0iSyLJJSgI6dhQ3bSwtgalTRcbON98AAwdqDyDlpYIczL94EfDxAV68ACpWBL76SvycsllgOL+otj1Prf43B9THLHJMVHzJJElbXiblhejoaNjZ2SEqKorLyoiIDEWhEP9Rz2BHSfVOMOHhBXL9PxFRru3ZA3TuLApKX70qghoZiY8HypcHnjwBVq4E/Pzyb56AKILdqlXW/Vq1An76SSzryg/HjwOdOgHR0YCnJ7BvH+DgUHB3TgPgPiUk0/MMDFFsYiysA6wBADFTY2BlamXgGVFu6RqDYL4gEREVL0ZGgJOT9sAQd4IhoqIuISGlntD48ZkHhQDA3Bz4+msREJo/HxgyBLCwyPNpqnl7i2D948fa6wypHD4MVKkCjBol5luyZMo5fQdr9uwBevYUQbPmzYHduwE7O3Eun5aF5cS1uWK1RFyiQp0pdH56W1ia8t87ouKuQOxKRkRElG927ADCwkSh0LS7SpYsya3qiaho+/57sdOYs7MIoOhi6FBRPPnJE7GFfX6Sy8WW9NqCQjKZuH33HdC2rSiQvXSpyHBaskQEboKDAXd3kVHUr5+4d3fP+U5mmzcDXbuKsTt1AvbuTQkK5bPs7i5maWr8/iZP1SZXtxNR8cXAEBERFR9RUaJWBgBMny7qQBw+LP5zD4haEQwKEVFR9fixqIEDAIsWATY2uj3OzExsZw8AAQFAXFzezC8jvr5As2bp21Xbuk+YAPz9N/DXX0DNmsCbN6KtbFmge/ecbXOvUIhlbL/+Ku4VCmDFCuDTT8Xxp5+Kx+dn9hTliewG2IiKIoaGiYio+Jg+XSwhq1gRmDw5JeXfyEgsDdi3T/yHn8vIiKgomjQJiI0FmjQB+vfP3mMHDRJBofBwYM0aUWg5vyQmAv/+K45XrhTZnWmXhMlkQPv2wEcfAT//LLKhMipILUmiv78/0KVL+vf84GDxR4TUASVbW1FPCADGjBGZV0aG+Rt7bncXszQ1Zj0hItLAwBARERUP584Bq1aJ4zVrRN0MlSZNgBIlgFevgDNnxNdEREXJiRPAli0iILJiRUpNNV2ZmIisoSFDgIULgc8/B6yt82auaR0+LIIyTk7AyJGZB2TkcmDwYBE46tAh436qbe7/+APo1i3l5xEcLLKJ0i5dUwWFevcWdeiy+/PTI+4uph+5DbARFSV8thMRUdGXnCw+xEiS+Ct5mzaa542NxV+at24VmUMMDBFRUaJQAKNHi+Phw4G6dXM2zmefAd9+K2oUrVolMi/zw++/i/suXXTP0nn9Wrd+3buLJXWVKgEVKojlaJkVuT51ClAqmVlaBDDARpSCgSEiIir6Vq0CLl4UWUFLlmjv06lTSmBo/vx8nR4RUZ5av14U3S9RIqXGUE4YGwOzZgEDBogaRSNHiiVWeUmpFFk9gMjs0ZWzs279ZDLg7VsgNFTcsvLwodjhzIA7j3F3McorciM5Pq74sfqYig8GhoiIqGh7/FjUFgKABQsAR0ft/dq3F3+JvnwZiIgQRUuJiAor1Rbtt2+L2kIAMHcuYG+fu3H79hVZQzdviiVpuu5sllP//CNqw9nZiR3FdJXVNvcymTh/4wbw4AFw6xawbZsoNp2VjGoX5RNtS5xUu4uR7hhgS8/c2Bwh/UIMPQ0yAO5KRkRERZu/PxATAzRuLJZQZKRUKcDLSxyH8D9FRFSIpd6ifcQIUR/H2FjU6MktVdYQACxeLHZ7zEuqZWQdOwKmpro/TrXNPZC+HpDq68BAwNISqFpVLFMbMUK3sXXNRqICzdLU+P1NnqpNrm4nKk4YGCIioqLrzz/FVsZyObB2bda1KVTb1jMwRESFlap4ctot2pOTReHkzLZo11WvXkC1amJb+MDA3I+XEUlKCQxlZxmZiq+v+DegTBnNdtU2976+mu2qLKOMCkvLZICbm+hXAKh2F7u/oCMDGUSUKzJJyqy6GulTdHQ07OzsEBUVBdu8Xo9NRFTcxcUB1asD9++LbZUXL876MZcvA7VqiR3LXr0Sf0kmIiosFAqRKZQ2KKSiWj4VHq61eHJcYrK6IO+1uT6ZBxt27BABIltb8T77wQe5n39aqvdkMzPg5cuc74KmWlb39Gn6be7TUgXWAM0laKpgkbaAEpEOsvX6MpDYxFg4LHYAADyf8BxWplYGnhHllq4xCGYMEVH+UyiAI0fEOv4jR8TXRPo2b574sOLmBsyerdtjatQQtYXi44FDh/JydkRE+nf8eMZBISBli/bjx3N/re7dgZo1xTK1xYvz5t/1XbvEfbt2OQ8KASII1LKlqI/UsmXmO4plN8tID+ISk+E+JQTuU0LUW6gTGUpcUhzikuIMPQ3KZwwMEVH+Sl33oF8/ce/urp/UdiKVq1dTMoRWrND9A4VMxuVklP8YLCd9uX9ft35piifHJSa/vylStSnU7VoZGQFz5ojjgIC8+XddtYysa9fcj5Udvr7iZ3n4MLBli7gPD2emEOVIjl5fRPms4OWvEVHRpUrPTruC9fFj0c70bMoN1VKBx4/F7mPJyaKYaJcu2RunY0dg9Wqxbf3q1RnXmiDSh+BgYOxYzSwPV1dRNJfvh6QrSRJLuyZP1q1/muLJquUtqal2aQKA+ws6ah9HqUy5fmr6+Hf9/n3g4kURgOrcOWdj5IYqyyibsrNcSBUUSBswUCmIS40o+3L8+iLKR3y3IaL8oVCIDz/ayppJkvjw7e8vPsRnluJNpI22D9cyGdChQ6YP0/of+FatAAsLMZaqvgVRXmCwnPTh4kXx/qdaHiaXZ5x1pqoxpI/iyQqF+HdbG338u65aRubtDdjb53CSBRsDBkRUUDAwRET5Izt1D3LwFzoqxjL6cC1JwMiR4gNFdj5cW1gAbdqIjKE9exgYorzBYDnpKqPCyS9eAF9/DaxfL54zFhbAlClAxYpA//7isdqKJwcGpntOXZvrA0Bkq6gCE+ent9XYxjudvP53XctuZAW5eC+zfygjOXp9EeUzvkMRUf5IU88g1/2IgMw/XKto+XCd5X/gO3VKCQxNm6b3aRMxWE460ZYNWaYM8NFHInASFSXa+vYFFi4UxfYBsYuXtiWKgYFaA+XaghaWpvLMgxl5+e/6ixfAiRPiOL/rC+VQTrJ/GDAoHnL0+iLKZ3w2ElH+SFPPINf9iIAcf7jO8j/wfh+Lg3/+EVskly6trxkXPdnZBppSMFhOWclsqWFQkDiuUwdYvhxo1kyzj6+vCIjn5WszL/9d371b1C+qWxcoV67IZuMwYEAFjZHMCC3KtVAfU/HBdx0iyh/e3oCLC/Dkifbz+qx7QMVHXn24dnMDatcGLl0C/voL+Oyz7M+tOGDh5JxjsJwyo0s25AcfiOC1qan28zkonmxpaqx7XRtvb/F6f/xY+zxz8++6qr7Q+2VkhaEWD7N/KCvZen0ZiIWJBY4MOmLoaZABMDBERPnH0THjwBCgte4BUaZsbHTrl+bDtU7/ge/USQSGQkIYGNKGhZNzJy8/VFPhl1U2JAC8fg2cOmW4pYZyuQgC9+ghnq/ansc5+Xf97Vtg/35xrKdlZPlRmyg32T+FIWBAREUb88OIKH/Mni12TjExARwcNM/JZMC2bfwQSdnz77/iL+qZkclE9k+aD9eWpsbvb/JUbXJ1OwCxbT0A7N0LJCXpc+aFX1aFkwFR2ymjnZEo5UN1ZhkhDJYXX4VlqaGvrwgClymT/lzZsiLAnl179wIJCUCFCkD16gBEMOfaXB+cn95W3e389Lbq9rwQl5gM9ykhcJ8Sol7KRkRUVDEwRER5b9cu4JtvxPFPP4msocOHgf/9T2R8SJLIJiLS1ebNQOPGwL17KdsYq3bcUclkBx6dNGwoagtFRQEnT+ZqukVOdmo7UcYsLbW3W1kx46o4S0gQS1h1URCWGvr6Avfvi3/Xt2wR2YSlSgEPHqT8258dqXcje/8+rlMwX4u4xOT3N83aRKr2vKDK/rm/oCNrBVGhE5sYC/vv7GH/nT1iE2MNPR3KR3y3IqK8df06MGCAOB47NmVJjir1/a+/xIf8kBCgeXODTJEKkcRE4KuvgJUrxdc+PuL5c/RotnbgUck0fV8uBzp0AH75RTw/uTNUisKSzVCQJSeL5zKQsnPe338DAQFi2/EuXQw6PTKQs2eBIUOAq1cz76fDUsN83do9bT2j5GSgVy9g/nyxHKxuXd3GSUwU77eAxjb1OZWT2kRFtdA1ka5exr009BTIAJgxRER5JypK/Mfu7VugRQvgu+/S91Et19mzJ3/nRoXP48fig4cqKDRjhvgAUapU+r9YHz4MhIfnPuNCtQyCz09NLJycez/8AFy7Jp6/s2aJ5/acOUDJkmInPGZbFS/v3gGTJgFeXiIoZG8PTJggAkD6zobMDz17iptCAQweLAI+ujh0CIiOFu8djRqlO50f2TjVZu5DtZn7NAJI9b85oG4nIiqKGPImoryhVIpMoZs3xV81t20T9YWQ5q+Y/m1gKZeLD0j37wPu7oabMxUM2rY/P3FC/PX5+XPAzk4sQ0xbuyIHO/BkqV07wNgYuHEDuHsXKF9ev+MXVt7egK2t+ACnDQsnZ+7NG2DmTHE8dy5QooQ4NjERmUIbN4qlZMxSK3q0vb/984/IErp1S/Tp318EfUqXFoGibGZDFpiMl1WrRJD+33/FkrK5c7N+jGoZWZcugFHu/37NncKIiHTDwBAR5Y1vvwV27wbMzES9gYxqCJUsCTRpIv6jHBIC+Pnl7zypYNG2/bmdncg6UyqBWrVEn/wK0JQoATRrBhw5Ip6fY8bkz3ULuuPHxe8kMwU5m8HQ5s0DXr0CqlUDRozQCJbf+KQrzDduFM/z5cv18uGYCght72/W1kBMjDh2dgbWrgU++STlvK+vCJKkDSZl8toyxNbuWpet2dsDq1frvqRMqQT++EMc62EZGZCzncIYTCKi4oj/2yAi/duzRyyNAIA1a4AGDQBkXAQysf3HKY+j4ku1/XnaosZRUeIDQ/PmwOnTGQaF8mwHGS4n0/TsGdC3rygw3aqVyF5Ia+5cFk7OyO3bwIoV4njJEpGRloqyTRuRjfX0qcgkoaIho/c3VVCoVSuROZs6KKSiyobs21fcF6aAa+olZYMGZb6k7J9/xPuLnZ1Bs+VyWuiaiKgw47sbEenXrVsiDV6SgJEjRW2B9zL6K2bFF7bYD4iU89hYsSMPFS+ZbX+uEh4uMtDyW8eOotbH0aMiS8bGJv/nUFAoFMCnnwKRkSLb5f/+DzA3T8lm+PVX0XbsmKFnWnBNmgQkJQHt2yOudVsgbbBcZgzTjh1h/OuvYjlZkyYGnCzphS7vb3fuZPjekt0i0vmZ8aLTsrVVq0TW5eXLmS8pUy0j69gRMDXV6zwz3WiAiIgYGCKiXEpdL8HOTnyAjo4WH2YCA3Ua4nbpsnho5wi3qGfAwYPa/2JKRVtW258DKdufp/lLcp7X06hcWWQp3b0LHDigtyUOhVJAgPgZWFoCO3YAVlbiQ+veWAC2uL54KSz++gvYv19kd3l5GXrGBcvhw8CuXSLjY8mSDIPlPvEeWAeILJMlS9IXH6bCJRfvbzmRk+VTOaXTsjXVkrKePTNeUiZJmtvUFwAMJlFxZCQzQn2X+upjKj4M+ts+duwYOnfuDBcXF8hkMuzatUvjvCRJmDlzJpydnWFhYYG2bdvi9u3bGn3+++8/9O/fH7a2tihRogSGDh2KGFVa7nv//vsvvL29YW5uDjc3NyxatCjdXHbs2IEqVarA3NwcNWvWxJ9//pntuRAVO8HBolh0q1ZAv37ir3zXr4u6LDt3pvuL37W5Prg21wfnp7dVt52f3hbX5rWHU9/3y05U29RS8XLvnm79tGx/nuc7yMhkKcvJivPz8/DhlCWiq1eLjKE0JHd3UXQeEHV0KIVCAYwfL44//1zrz0/liEc9xJqYAw8eAKGh+TRByjM5fH/LaPm1qr1Q6dEj8yVlV66I4LuZGdC+vUGmSESAhYkFzg0/h3PDz8HCxMLQ06F8ZNDAUGxsLGrXro1Vq1ZpPb9o0SIsX74ca9euxZkzZ2BlZQUfHx/Ex8er+/Tv3x9Xr17F/v37sWfPHhw7dgwjRoxQn4+Ojka7du1Qrlw5hIaG4rvvvsPs2bPxww8/qPucOnUKffv2xdChQ3Hx4kV07doVXbt2xZUrV7I1F6JiJaN6CYDYcef06XTNma3bN+nyPksoJCTzdHsqWmJigIULAX9/3fobavvzju//ahwSIuod5ReFQizB+PVXca9QZPWIvPHsmQj+KpVieejAgRl+aH03YRIkuRz46y/g/HnDzLcg2rQJCAsTmZVz5gDIOFh+MeATmH3yPhi5c6cBJkt6c+AAMHWqbn3TvL/lNuidH1u7Z/gHn/ftGlatEtlDly+nDxyrsoXatRMFuYmIKF/JJKlgfAKTyWT4/fff0bVrVwAiQ8fFxQVfffUVJkyYAACIioqCo6MjgoKC0KdPH1y/fh3VqlXDuXPnUL++SHnbu3cvPv74Yzx69AguLi5Ys2YNvv76a0RGRsL0ffbClClTsGvXLty4cQMA0Lt3b8TGxmJPqsKijRs3hqenJ9auXavTXHQRHR0NOzs7REVFwdbWVi8/NyKDUChEplBGqfGqrarDw7UWydRaLyE+HihVCoiLAy5eBDw9827+lD+0bcusej7ExYnC5AsXAi9eiDZjYyA5g7+CZ/KcSr2UTFs9Db18IEpIEFtHx8QA584B7//NyVPadjBydQWWLcvfws4KhfgL/oEDQPXqwNmzgKUl3KdknD21JGQpul85JJaFqnYZKs7evgUqVRK1mRYvBr76SuO01vfEbduAPn2AChVE7TYuJytcoqOBiRMB1R8i5fKMA7sZvL9l9hoD8mZ3sZzSuQ7Szp0ic0guB86cAerVE+116ojA6YYNGrUJiYgod3SNQRTYhYPh4eGIjIxE27Ypf4Gws7NDo0aNcPp9JsLp06dRokQJdVAIANq2bQsjIyOcOXNG3ad58+bqoBAA+Pj44ObNm3j9+rW6T+rrqPqorqPLXLRJSEhAdHS0xo2oSMiqXoIkpdRL0ELrXzHNzYE2bcRxcV6uU1SkXWbYqpX4eutWEdj48ENRj+rFC1G/5+efgS1bAJkMUtoPwKqvM9j+PF92kDEzAz76SBznx/Mzo4y8x49Fe3Bw3s9BZf78lLpC27eL+yysatxLbLO+e7cI9BZ3CxeKoFD58sCoUbo95uOPxfvinTsiw4IKj/37gZo1U4JCo0aJjLFsvr9lKxunsEi7pOzdO5ERGRYmfhYdOhh6hkTFWlxSHNwD3eEe6I64pDhDT4fyUYENDEVGRgIAHB0dNdodHR3V5yIjI+Hg4KBx3tjYGCVLltToo22M1NfIqE/q81nNRZuAgADY2dmpb25ubll810SFhJY6L7nqp8JtwYuGjIIajx6J7Zb9/cXSJHd34KefRF2qzz5DXJduSNi6DUoXF42HKcuUQcLWbYbf/jy/np+Z7WCkavP3z59lZYcPA7Nni+M1azTq4mT2oXXPqqEi2wUQuxAVZxERooA0AHz3ndad9bQGy21sAJ/3H/65nKzg0bbMMzoaGDFCLIeKiAA8PMRraMUKxPXsne33t8K0bXq2lq2plpRduQI4Ooo/HgDi/a1Bg/wNfBORBkmS8CDqAR5EPUABWVhE+aRg/atSxEydOhXjVYUmIdK4GByiIuHhQ936ZbcezMcfi/szZ0Qmib199h5PhqfLtsxyObByJTBkiEaBcrEMwRJG/Vaj4aOrcIh5jefWH+Csa3UoL8hxv1fml87zHWRUz8/z50X2h5NT3lwnOxl5etjBKEORkSKQp1SK35WqqPR7We589PXX4kNzcLDIeKlZM+/mWpBNmSKWyrZoIXZjyo7u3cVSvN9+y3iLb8p/2pZ5li4tXpuvXomvR40Su/i9r5eT2/e3IsXeHhg4UCyrfPtW85wqK3LnTsP/MYCIqBgpsBlDTu//w/3s2TON9mfPnqnPOTk54fnz5xrnk5OT8d9//2n00TZG6mtk1Cf1+azmoo2ZmRlsbW01bkSFWkKCqI0xeTIAIKOP/pJMBri5iZoy2eHqKmoLSZIoXEuFjy7bMisUQJUq6XatU1EayfFP2VrYXa0F/ilbC0qj9MvHDMLJKaW2UJqdK/UqrzLyspI6A+LgQaB/f5HZVb06sGJF9serVk18wAOKb9bQP/+In6dMBnz/ffbrBHXuDJiYANeuicw6ylx+FGvPKCPy5UsRFHJ0FNdesUJrEeWcvL/lRxHpfKVQiGXF2uR3ViQREQEowIEhDw8PODk54eDBg+q26OhonDlzBl5eXgAALy8vvHnzBqGptnI9dOgQlEolGjVqpO5z7NgxJCUlqfvs378flStXxgcffKDuk/o6qj6q6+gyF6Ii7+ZNwMsLWLoUAHDIox4kAGn3Z1JCpKFmVA8mS6l3fyouCsrOU/qQi6BGoainkR/b1uuaaafPHdrS1oRq2xY4dEgE73bsyLSuUKYfWqdPF/c7dhSfwIbq9bxli8i0AkQtlTp1sj9WiRLidwGIrCHKWEZ1zfS5LEmXjEgTE6BZs3TNheL9Lb/ksk4hERHpn0EDQzExMQgLC0NYWBgAUeQ5LCwMERERkMlk8Pf3xzfffIPdu3fj8uXLGDBgAFxcXNQ7l1WtWhXt27fH8OHDcfbsWZw8eRKjRo1Cnz594PJ+DXe/fv1gamqKoUOH4urVq9i2bRuWLVumscRr7Nix2Lt3L5YsWYIbN25g9uzZOH/+PEa9LxCpy1yIiixJAjZuBOrWFUVkS5UC/vgDQ3rNwciu0xBpU1qje6RNaYzsOi3nKeCqD9579wKpArpFVn58mMkvCoXIkNCFlqBGoainoQpc/v23yKDLC97eUJZxzTAjD4DYwc3CQj/Xe58BIWn7oJaYmLuATq1aQLdu4n3k229zPk5hkfr13L+/+NnJZEDTpjkfs3t3cc/AUMYyeg7rUqw9O4H5I0eyzoh89EhrQKNQvL/lF0NlRRIRUcYkAzp8+LAEsRpF4zZw4EBJkiRJqVRKM2bMkBwdHSUzMzOpTZs20s2bNzXGePXqldS3b1/J2tpasrW1lQYPHiy9fftWo8+lS5ekZs2aSWZmZlKZMmWkBQsWpJvL9u3bpUqVKkmmpqZS9erVpZCQEI3zuswlK1FRURIAKSoqKluPI8oXycmSdPiwJG3ZIu6TkyXp9WtJ6t1bksTHOklq1UqSHj2SJEmSYhOSpNiEJOnFm1ipd9/50ujOE6U3f+6TYuPipdiEpNzNo3Rpcb3Dh/XwjRVgv/0mSf/f3p2HN1WlfwD/3u4LtGVp6UDLJqBTUIogUhkGWev8UNkqFVEQBUToACJuyMjiDCi4wYCiwwgOO2hxQQSxrA47U5RNQC2ytQVUKN3b5Pz+OCRtmqS5SZObpPl+nidP29u7nJucJPe895z3KIrQG55fw0NR5OOTT9xdQvX27ROiQwfjOZid082HDhAiPl6+zlYUlJSJZi9sFM1e2FizuuQKOp0QsbHyfObNM32/ONEbfxpm8XnUVV4WGCjE3LmyTI4qLxciLs7ia2WsizZeL5v+9z+5Lz8/Iez83vQq1t7PhufR0ffzlStC+PvL/fz4o3PLXBvUpA5/8onQNamybVyc6WtVUiLE5s1CjBkjRESE9eNUfqxaZbW4Hv35ppXt29U9j7X9GoDIA+WX5AvMgMAMiPySfHcXh5xAbQzCrYEhX8PAEHksSxfH0dHyAchGyezZFi+sXXKR+9hj8rjPPuuc/XkiLRrkTlRQWGwMABZ9/U1Fua5elQ0mRZHljooSK9snC50hCFQlqKEDvCvgZUnPnuavV9XGZE3odOK72FZCACI/MMTkOBfrNhST+k0WYvDgiuV9+giRne3YsbRqoD3wgNzPzRs/tY6r38+9esn9vP66c8tdG6itw9u2mW5nKzA/ZYoQw4YJERmpbv8MaKhXXi4u1m1o9h1hzw0EInKNgtICkbAoQSQsShAFpQXuLg45gdoYhMfmGCIijdzsgq9crNI9/soV+YiJAf77X+CllxzLGeQILfK4uJs35VhIT0dI61ZYs3oqFnwxDyF9e8vhMuPHA7feCnzwgSzviBHAqVMYcGAjytaug2jSxHQ/cXEoW7vOu2eaSU+XuXeqUjNkRa1Vq3BHzo8Qdeui+MRJPDx0NiY88Byub9qCqNwL+Ef66zJnz/vvy+FkW7fKIVuVEmIXFpXg4UfmYMKDz6N4a4bl4TE6ndxWjZoO6fjb3+TPFSuAn35yeDeFpeVo/uKXaP7ilygsLa9ZmZzJ1e9nDiezTm3d7NdPToU+bBgwYwbE6NEQQsAsHbi8aSpnzFq5Erh+XSaeHzsW+OorZNdpYJZbz0APODbxgq/x98fMXmMAWM5TCMDxPIVEVCNhgWE4Pu44jo87jrBA6/kFqRbSJExFQgj2GCLtqO7FU14udE3irA770QNCNGmi/V2733/3yqETqp/3khIhnnyyxkMStFC8dp3QW7irbvJ3u3ZC7Npltq3VXkbeytb7xRm9vAoL5T4AIWbPtl2njh8X4o47KsoxaZIQa9ZYHx6j1wtx5IjsDdG4sbY9IP7yF7mvJ590eBceW6dWrXLt+zk7u6JX3i+/OLfsHkj1Z+n33wtx11329+hR+xgyRIj//tdkuKbxM9HwelR6/+u9bQiwGxWUlInitetEeZMmpr2F4uJE8dp17i4eEVGtwR5DRGTb7t3wu3jB/I7pTQoge0Jo3WslKqrijqs39RrS6dDl3Pd48MRO+O3cad5Lo7wc+OgjOVX7v/+tbp95eRYXO9pzwq7tdDr8OmqcxbvqCiCTI0dFAQcPWr5D7l8xLbO+e3fvv/tr6/3ijF5e77wj9xEfL6drtiUhAdi/H5gwwbi9ePhhsx6A4uJFiMGDgWbNgMRE2Rvi0iUgKgoiPNxqomuhKM7rAWHoNfTRRyg6/aNd9bewtBwl69YjuPUtJj3X9M2ao2TdelXb2/t+Ub2NTid7Varh6ExysbEVM115Y2J6Z7t4EXjySVmXDx40Jqm0RCgKEBcHfP89sGED8NprQPfu6o4zYABwzz2AX8XlcvCQh6B8/DFEY9MekUpcHJSPP/buHpEaCgsKQPCQh1By5idjr8jir7+B39mzCB7ykLuLR0TkcxgYIvJg9jZmCkvL5aOo1BigKMvYhsKiEtPthZCNyVmz1BXEHTODeNG09TYbrXo9sGYN0LatnLY6KwuIiYGIjJSNFguMjZyxY+WU1zk5Wp1Ohd270fjGVatfFAoAXLtmdSayaqcx90aunknn8mVgzhz5++zZQGiouucwJASYPx/49FPooEABzAN5huDe+fNyOu3Bg2UjOScHyn/+A0VRzOuiIvfltCEdSUly6vXycgS8Mc+uTZ9JnY7A1CFQLl40/cfFCwhMHWI7WGIraOuo774DunQBFi0CYCM4UdMAmw8MJ7P5HXbjhgwwtm4NfPih/GxNSYGycGH1dXj+fOD222Wg54UXgBkz1BXIWiBv0CAUn/nRJKCBrCwGhRxR224gEHm5wrJCtH23Ldq+2xaFZYXuLg5pSZsOTCQEh5KR/exN7NzshY1izICp4mLdhiZdsy/WbSjGDJgqZ7d5+2059MfTE2mePCmPHRQkRJWZBrVgz3M/ZsBUq8mW9UDF0CBAiAYN5ExSBQUVyU+rDEkwJj/t3r1iWd26Qrz+uijIy3doNji7Z5HLyjKdkc6Dh7tpxtWJmp9+Wm7fsaNjM42pLd8XX5hvaykBfXy804fFFGXIMuoDAsTTD76grv7WIFGt1eEqTawPVzG+V24UGz8DrtwoNi4XQsghfy+8UDHkNTJSiLFjq38/1/S5PHeuYn+XLtVsXxpx1nfYpToNxMo7kismRACEuOceIfbsqdjYnjpsSBZe9bWq/Jox+TER+SDOSlb7cFYyD8TAUO3gyCxc9m6jqmFigc0ARUBAxfKQEDnjSnS0Z14c6/VCtGwpy7Fhg+aHtydPU3WNVpPAzqxZQlR9/9tqzOzdK0Tnzsb//VzvD2JhlxRxsW4Dy8E/K2wGDYUQIidHiAULhEhK8vzAoTvYakxWE6Cw6cSJiiDDjh2Ola+meW7Ky+VruWqV/OmC932zFzaKHxo2NSuT1fpbVCTrpJrzmjtXiIsX5WfHTdV9JlqbIc/wvm/x3GfGIGrq0NmixXOfiWYvbBTim2+EuOWWiv2lpFQEalwdYLv7brnPRYucsz8Xs/e7z9rrZZLXq3VrIdLTTV5nI3vqsK3APHMFEZEPYmCo9lEbg6gFffuJap+EV7YAAPz0OnS5cBwx+b8jbcz3OBDXFno/f5x9rZ/5Rjod3jv4H4vDSIxDgcrLgQ4dgNGjgaFDZX6Ym7OSCUWROVIMDF3y3TUziKLI2ckWLAA2bpRDADRgGHJXWKqrtKzid7PhPDeHW9m0ciXwwAPmywcNgl///jIvTXa2HLrQrVvFc96lC7B3L7B8OfDii2iRk43x+z42G7ISe+Mq3vt0NpDe0eJwhuRTe+T/LWy3+NPZQPuNwLFjcmgGIJ//7t3lUJlr12STqSpD7g5fmYHH318OSbH0fjFIS7P6fiksLTe+t0/MSjatS889J4c39e+vPv9JVWrz11hbz98fuPdex46tUvKpPWhz9ZzZcmP9XdYaqF9f5uz59lvg0CGgtFTdzp9/Xj7q1wfatQMSEjD3q+VWPxP1gMzj1L+/2WuWfGoPpmd8YPLezqlTHz/XiwNe/14uaNIEePdd4MEHKza09X6uqcGD5TDgTz4Bxo1zzj5Vqrb+WlhX/lT5OQpU+x1myGmmREXJXEEhIZYPbE8dHjQI+PhjKBMnms4oFxcnv/c4LIyIiHwIA0Pks+y5yDWsL3+qv9B16OL4JksNk0t1G96c4rVKYKisDFiyBH5Vp5y35K23TC+cPfniuF8/GRjatEkGJqzk43EmQ52orNPfvzH+bhaUu3RJ3Y7z863/z1Zjxs9PTgXfvz9EfFMg/4bFhq4AgKeeAoKDgfBw+TMkBAgMxHv7Pqw+aPj9zcZu584yaDhkCNC4sTFwCEUxDQ65O3DoLtbeL0FBMoAxZ47Mo3Pnner3mZEhc2kFBABz5zpetm7d5Pv24kXPDOTdbPhbYqy/I0ea/zMqSgYnbYmPl+f+22/Arl3Arl2IrGZ1P0DmXFq1CnjoIWOw4dSdhQiaO8fsOWyU/xti83+Tf4wfL/NARUSY79iVAbbBg2Xwa+dO4MoVIDraNcepIbs/RwFjcndrTHKaOev5HTRIBgZdFcgjIiLyEgwMEankyIWuQxfHsN4w+UP+r1j82Rxg+W1Aw4YVd9UPHACKitSdiKXEuJ56cdy9uwxwZGcDmZn2NbZryE+vQ+ebvbUu16ln7K1llJUFrFgBvP++uh06OhtRZUeOQMm/YfXfCgBcvSp7WlWhaqaBFSuAYcNMl90MhMATA4fuYun9kpgoA5l79sjA0LZtchlsBIh1OoRNmSJ/HzsWaNPG8XJV6tHkkYE8NQ1/AGjaFOjbF+jaVc7E1bw50KKF7YBXVpYMkv/wg+z9tnat7G1oy/Dh8hETAzRtiuDjxy0ex1i+mBj5PLvjeWzZUvb6zMwEPvsMhcMft+sGhyNqcoPD5ucoIJ/rXbsqZq2zxdmTIWjQU46IiMjTMTBEHsXeXjyObFeTi1xA5YVuTeh0CH52suWGiWHZ8OHm29WtK2dsscWNw0jsFhwM9OkDfPopsHEjCtvd4fJG0IlZyfD/dAMCJj8D/0ozIOmbxKHs1VeBf/1LDuuqPCV51UZ4Zc7spaG2QdSsmQyoFRcDJSXA9evV91gy8LMSPvLUwKE7WXq/fPWVDGjs318RHLrjjmoDxIOPZuDNI0eAyEhg+vSal8uTA3lq6+9rr8lea5WpDXj5+8uAXGKiPGc1gaGQEPleuXxZPmy5fFm+F9z1eTl4sAwMffIJMPxxlx/OkRsc1X6OvvWW/CM7G/joIzm72Jkz6gvkjCA7ERERmWBgiHyOo714VF3oWtgGkIEnwzEOTeuNsKBqGtS7d5s26Kxp3FgGTf70J3lnvVUreTfZU4eROKpfPxkY+vJL4MWpDu3CnsBh2MbPgYdTIao8h34XLyD4iUrDXBQF6NULeOwx2Rh97DG53JW9NNQ2iJYtM2207tgB9OhRs/17YuDQ00REAFu2yPflwYOyfmzfbnX1kLJiTNl1c2jVyy/LXoDO4KmBvJrkQHIk4KV2aN3PPwN5ecAvv8hec1Y+z004u9eKPVJSgGnTIDIyUJRbMdTYnhscrmb1c/TSRQSnDgHmdZLBLd3NMtepA6SmAl98IYfI1abvMCIiL6IoCppFNjP+Tr6DgSHyCI724qlp7x97VHuh+3AqEOBv1jgxHl+nQ5dz3yMm/3fU2RuCkJ73Wm6knT8PfPCBugK98Ybjd9W9yf/9n/x54ACKLlTk83HJ66zTyYanEGa5eIwCAoBXXwUefVQ2UgxCQ13fS8PRHDKennumNomMBL7+WvYYOnwY6NkTJ7d+A/HHBLMAccQbryEo/1fZw+uvf3VuOTwxkFfTemhvwEvt0LqAAJmwun592btOTWDInb1Wbr0Vpxo2xa1Xz+EfT88F2vUCoO4GhyPsvsFR3eeo4TU4dEj+vOceYNQomeOpTh3mNCMicrOwwDCcnXTW3cUgN1BE1VYuuUxeXh4iIyNx/fp1RFhKWFkLqe2p0fzFL6vdj7WLXEe2qxxMsnSRa222FDRvbr0nT+UcF1UvWtPToZ8w0TS3RlycbLAMGiTvjq5fD6xeLfMFqbV9u+WGX3q6eYAiPt79w0hq4GhsK9ye+xOm/N8kfHx7b7P/W6sfdr/WanvWWHvudTrX99IwNJwAyw2njz+2/Do7uh055rffZHAoMxNo1AjYsQOFzVrgiSffQkz+75g77C6EPPE4UFgo3/sPP+zuEmvDHfXQns9Ew2e9mnxGbgxQzO/6CCbuWY2tre7G6MHmuXlsBYYcGbZdWFRSUX//mmz9Bofaz9Fly2RS/apq4XcYERGRu6iNQbDHEKniaO4fT2R3Lx7A9vAuIWRvn3/9Cxg4UCYnVRRjI8ivagPj4kWZJyIxETh6tKI7vaLIYML338s711rcVfcC227pjNtzf0LPHw9YDAxZY/ewQbXDQ6ytp0UvDUdzyHhy7pnaqH59YOtWOZzsu++ApCSEBAdjTW6u/P8XN9dr3VoOofEV7qiH9nwmenoC75vGLJgCdFqN3uePILykEAXBYbaHKddEejpCJkzEGsMNji/mmd7gAORzlZkpl6kRFGR5eS38DiMiIvJ03tu6J49m7xAvh3Lx1GA7VRe5gOzN8803wOLF1e/P4Omn5SM4WN7hPH/ecnDHsOzIEfmzU6eKKcLj4mrend4Th5HUwFNz04A/rcZ92UcRqCtDmX+gaxpBv/2mbj13Jz91tOHEBpe2GjSQnx8dOwLnzlmeGe7MGWDDBt8KzLmjHtrzmegFQdTQOzsArVtDOXMGPX86iC8SuiMsyN/mTRuHhl9Xd4MjJQWYNUvOhvjppzJPk1rMaUZE5HGKyorw52V/BgDsenwXQgND3Vwi0goDQ1QtR3P42NtTw9J+1FzkOrSdrYvcGTPk1O9ffw3873/VHt9MgwYyuFBSAvz4o7ptli+X+Woq84KGiZZCkroAMTHwu3wZd50/jj3NE1XVD7sCh5s3A889V31BPCkXj6MNJza4tFWvHlBebv3/igJMmiQDJb4UoPP0eujpQVRFkb1OX3sNjxz5CgoAv50hQHU9X+FAL8pK+YLMGJZVnmY+LAy47z45nOz335nTjIjIy+iFHocuHTL+Tr6DgSGqlqMzeHksNRe5VaeMbt9e5gr56CPg119t553Q6WQwZ+lS4O9/t10maxfxnt4w0ZKfn0xCvWwZev50EHuaJ6raTHXgcPVqYPhw2YBPTJRDfwCPHUZCXmT3buDSJev/NwxDdef052SZpwev6tUDACSdP4ak88es93ytCbWzZPbtC4wbJ3+GhjKJNBERkZdhYIhcwtEhXmFBAQ4Fm8L8FZy9L1wGUPZ8az2AovYit3dvGSjo0weIjZXL7rlH3YWuv7+cNr5XL3WBIXanV6dfP2DZMozKO4lRzgxILlokZ4QSQg7nW7YM2LiRvbXIOWqat4rIkvR04MUXzZcber5aSeJt93ez2nr5+OPyRoYBe70SERF5FQaGqFo1CfCYL7M99MehWZ0szWBS9a5pbi6waRPw3nvV78vgiSfMp4K390KXU4Q7V9++si6cPg28/TbQoYPqHlQWA45CADNnygcApKXJOuPnx95a5Dxq81G5O28VeQ9bPV+rGZ5o93dzTeovP0eJiIi8BgNDVC2HAzyOUBPgsbRNSor5BbLhrmlqKvDzz8CBA/aVxdrFcC2c3cZrfPMNEBAgG0WTJ8tlaodNVA04du0KPPOM7C0EyLxSr7xS8boA7K1FzsEAMTmb2lkynTE8sbTU/PurMlv1l5+jREREXoGBIXIp1UPDbAV4LHWLV5MvaM2aimUdO8o8Ne+/L2cbc7SRVstmt/EKjtSPyttWff5DQ2WCcUUB/vlPYPx415WdfBsDxORsThieqOq7ed06OTGCoc6y/hIREdVaDAyRKo7m/lFFTbf4cePkzytXgJwc+Th2TF2+oClTZO+Qxo3l34mJ2jbS2J2+ZmowbMJqQKmoSP6cOJFBIXI9BojJmdQO7zLkx3PEwoXAhAnyszMlRT6mTGH9JSLyAQ3DGrq7COQGihDW+geTs+Xl5SEyMhLXr19HRESEu4vjOXbsAHr0cN3+V60yzxdkqRdJfDwvcj2R2vrRqBHQooVsDP3hD0BMDLBggZwy2Zr4eDmTHIN0pAVHcqgRVaXTAc2bWx+eaJCcDCxZIgM4agkhh9UaJk4YN05+jvr7s/4SERF5IbUxCPYYItdScyF56JC6fbVsCbRtKxv+sbHA9evygtUWJsX0bmqHTeTmyoc9OE04aYn5VsgZbA1PFELmY9uyBWjXTt7wGDHCNIeaJeXlwNNPy2ASAMyaBUybVrEd6y8REVGtxcAQuU51yaS7dZP5f/7zH/WBoX//2/SiVKeTx3A0qSsvcr2D2mETCxfK4YI5OTKY9O23wPbttrfjNOFE5G1sDU9MSJDBoAMHgJEj5boffFAxpLrqTZtOnWQ+oc8+kzMzLl4MjB7tllMjIiIi7XEomYZ8aiiZtdwuBn5+gF4vf/f3BwIDgeJiy+saAjyWhvwYjgNYzhdUXVJi8g62hk1Yqx9qh6Bt384AIRF5p+p65ZaXA2++KYeGlZYCUVEy2X5oqMzLVjmgFBQk1wkOBlavBgYOdMfZEBGRmxWVFeEvK/8CAPhq2FcIDQx1c4moptTGIBgY0pBXB4bsyS1gaMjbSgzdsaO8o/nww3LfjgZ4mC+o9nMkAOhoQImIqDY5fhx4/HF1vXNffVUOHyMiIp9UUFqAOnPqAADyX8pHeFC4m0tENaU2BuGnYZnIW6WnywZ2jx7AI4/In82by+VV6fXA0qXqZgt74w3gr38FoqMrusU3aWK6Tlyc7V4/gwYBZ8/Knh+rVsmfWVkMCtUmjtQPQx4OwDy3BqdZJiJf0bYtsHevDPpUR1HkcDOdTptyERERkcdgjyENeWWPIWtDwgwN6/XrgdtvB7ZtAzIyZFDm11/V7dvSbGGc9YSq40j9YI8yIiIOryUiIpvYY6j24axkLrJo0SLMmzcPOTk5aN++Pf75z3+ic+fO7i6Wa+h0skFtKXZoWJaaan53MSTEer6gyiwlFWZCaKqOI/WDM9AREalPtM+E/ERERD6HgSE7rF27FpMnT8bixYtx991345133kFycjJOnTqFmJgYdxfP+Xbvtj0kTKeT0+L+6U9Az55Ar17AnXcCrVs7PlsYkbMx4EhEvk7tDI9q1yMiIqJagzmG7PDWW29h9OjRGDlyJBISErB48WKEhYXhww8/dHfRXEPtXcMlS2TX87/9DbjnHtljiLldiIiIPEe3bvKmTNXvZQNFkcNsedOGiIjI5zAwpFJpaSkOHz6M3r17G5f5+fmhd+/e2Lt3r8VtSkpKkJeXZ/LwKmrvGjZrZr6sJsmkiYiIyLmYkJ+IiFQICwxDWGCYu4tBGmNgSKWrV69Cp9OhUaNGJssbNWqEnJwci9vMmTMHkZGRxkd8fLwWRXWemt5d5GxhREREnoM3bYiIqBrhQeEomFqAgqkFTDztY5hjyIVeeuklTJ482fh3Xl6edwWHDHcXU1JkEKhyviC1dxeZ24WIiMhzMCE/ERERVcHAkEoNGzaEv78/cnNzTZbn5uYiNjbW4jbBwcEIDg7WoniuY7i7WHW677g4TvdNRETkjXjThoiIiCrhUDKVgoKC0LFjR2RkZBiX6fV6ZGRkICkpyY0l0wCHhBEREREREdVqxeXF6LeqH/qt6ofi8mJ3F4c0xB5Ddpg8eTJGjBiBTp06oXPnznjnnXdQUFCAkSNHurtorse7i0RERERERLWWTq/DpjObjL+T72BgyA6pqam4cuUKXnnlFeTk5CAxMRGbN282S0hNREREREREROQNGBiyU1paGtLS0txdDCIiIiIiIiKiGmOOISIiIiIiIiIiH8XAEBERERERERGRj2JgiIiIiIiIiIjIRzHHkIaEEACAvLw8N5eEiIiIiIiIqEJBaQFwc5b6vLw86II4M5m3M8QeDLEIaxRhaw1ymgsXLiA+Pt7dxSAiIiIiIiIiH3H+/HnExcVZ/T8DQxrS6/W4dOkS6tatC0VR3F0cu+Xl5SE+Ph7nz59HRESEu4tDPor1kDwF6yJ5AtZD8hSsi+QJWA/JE3hSPRRC4MaNG2jcuDH8/KxnEuJQMg35+flVG6XzFhEREW6v4ESsh+QpWBfJE7AekqdgXSRPwHpInsBT6mFkZKTNdZh8moiIiIiIiIjIRzEwRERERERERETkoxgYItWCg4Mxffp0BAcHu7so5MNYD8lTsC6SJ2A9JE/BukiegPWQPIE31kMmnyYiIiIiIiIi8lHsMURERERERERE5KMYGCIiIiIiIiIi8lEMDBERERERERER+SgGhoiIiIiIiIiIfBQDQz5kzpw5uOuuu1C3bl3ExMRgwIABOHXqlMk6xcXFGD9+PBo0aIA6depg8ODByM3NNVlnwoQJ6NixI4KDg5GYmGh2nBkzZkBRFLNHeHi4K0+PvIhWdREAtmzZgi5duqBu3bqIjo7G4MGDcfbsWRedGXkTLevhunXrkJiYiLCwMDRr1gzz5s1z1WmRl3FGPfzuu+8wdOhQxMfHIzQ0FH/84x8xf/58s2Pt2LEDd955J4KDg9GqVSssW7bM1adHXkSrupidnY1HHnkEbdq0gZ+fHyZNmqTF6ZEX0aoupqeno0+fPoiOjkZERASSkpKwZcsWTc6RPJ9W9fDbb79F165d0aBBA4SGhuK2227D22+/rck5VsbAkA/ZuXMnxo8fj3379mHr1q0oKytD3759UVBQYFznmWeewRdffIH169dj586duHTpEgYNGmS2ryeeeAKpqakWjzNlyhRkZ2ebPBISEvDQQw+57NzIu2hVF7OystC/f3/07NkTR44cwZYtW3D16lWL+yHfo1U9/OqrrzBs2DCMHTsWx44dw7vvvou3334bCxcudNm5kfdwRj08fPgwYmJisGLFChw/fhwvv/wyXnrpJZM6lpWVhX79+qFHjx44cuQIJk2ahFGjRrERREZa1cWSkhJER0dj2rRpaN++vabnSN5Bq7q4a9cu9OnTB5s2bcLhw4fRo0cPPPDAA8jMzNT0fMkzaVUPw8PDkZaWhl27duHkyZOYNm0apk2bhg8++EDT84Ugn3X58mUBQOzcuVMIIcS1a9dEYGCgWL9+vXGdkydPCgBi7969ZttPnz5dtG/f3uZxjhw5IgCIXbt2Oa3sVLu4qi6uX79eBAQECJ1OZ1z2+eefC0VRRGlpqfNPhLyaq+rh0KFDRUpKismyBQsWiLi4OKHX6517EuT1aloPDcaNGyd69Ohh/Pv5558Xbdu2NVknNTVVJCcnO/kMqLZwVV2srHv37mLixIlOLTfVPlrURYOEhAQxc+ZM5xScahUt6+HAgQPFo48+6pyCq8QeQz7s+vXrAID69esDkBHNsrIy9O7d27jObbfdhqZNm2Lv3r0OH2fJkiVo06YNunXrVrMCU63lqrrYsWNH+Pn5YenSpdDpdLh+/TqWL1+O3r17IzAw0LknQV7PVfWwpKQEISEhJstCQ0Nx4cIF/PLLL04oOdUmzqqH169fN+4DAPbu3WuyDwBITk6u0fc71W6uqotE9tKqLur1ety4cYP1lSzSqh5mZmZiz5496N69u5NKrg4DQz5Kr9dj0qRJ6Nq1K9q1awcAyMnJQVBQEKKiokzWbdSoEXJychw6TnFxMVauXIknn3yypkWmWsqVdbFFixb4+uuvMXXqVAQHByMqKgoXLlzAunXrnHkKVAu4sh4mJycjPT0dGRkZ0Ov1OH36NN58800AMtcGkYGz6uGePXuwdu1ajBkzxrgsJycHjRo1MttHXl4eioqKnHsi5PVcWReJ7KFlXXzjjTeQn5+PIUOGOK38VDtoUQ/j4uIQHByMTp06Yfz48Rg1apTTz6M6AZoejTzG+PHjcezYMXz77bcuPc6GDRtw48YNjBgxwqXHIe/lyrqYk5OD0aNHY8SIERg6dChu3LiBV155BSkpKdi6dSsURXH6Mck7ubIejh49Gj/99BPuv/9+lJWVISIiAhMnTsSMGTPg58f7M1TBGfXw2LFj6N+/P6ZPn46+ffs6sXTkS1gXyVNoVRdXrVqFmTNn4rPPPkNMTIzDx6LaSYt6uHv3buTn52Pfvn148cUX0apVKwwdOrQmxbYLr0h9UFpaGjZu3Ijt27cjLi7OuDw2NhalpaW4du2ayfq5ubmIjY116FhLlizB/fffb3aXkghwfV1ctGgRIiMjMXfuXHTo0AF//vOfsWLFCmRkZGD//v3OOg3ycq6uh4qi4PXXX0d+fj5++eUX5OTkoHPnzgCAli1bOuUcyPs5ox6eOHECvXr1wpgxYzBt2jST/8XGxprNqJebm4uIiAiEhoY692TIq7m6LhKppVVdXLNmDUaNGoV169aZDbkl0qoetmjRArfffjtGjx6NZ555BjNmzHD2qVSLgSEfIoRAWloaNmzYgG3btqFFixYm/+/YsSMCAwORkZFhXHbq1CmcO3cOSUlJdh8vKysL27dv5zAyMqNVXSwsLDTrkeHv7w9Adgkl36b1Z6K/vz+aNGmCoKAgrF69GklJSYiOjq7xeZB3c1Y9PH78OHr06IERI0bgH//4h9lxkpKSTPYBAFu3bnWoLlPtpFVdJLJFy7q4evVqjBw5EqtXr0a/fv1cc0Lkldz5majX61FSUuKcE1FL01TX5FZPP/20iIyMFDt27BDZ2dnGR2FhoXGdsWPHiqZNm4pt27aJQ4cOiaSkJJGUlGSynzNnzojMzEzx1FNPiTZt2ojMzEyRmZkpSkpKTNabNm2aaNy4sSgvL9fk/Mh7aFUXMzIyhKIoYubMmeL06dPi8OHDIjk5WTRr1szkWOSbtKqHV65cEe+99544efKkyMzMFBMmTBAhISFi//79mp4veSZn1MOjR4+K6Oho8eijj5rs4/Lly8Z1fv75ZxEWFiaee+45cfLkSbFo0SLh7+8vNm/erOn5kufSqi4KIYyfkx07dhSPPPKIyMzMFMePH9fsXMmzaVUXV65cKQICAsSiRYtM1rl27Zqm50ueSat6uHDhQvH555+L06dPi9OnT4slS5aIunXripdfflnT82VgyIcAsPhYunSpcZ2ioiIxbtw4Ua9ePREWFiYGDhwosrOzTfbTvXt3i/vJysoyrqPT6URcXJyYOnWqRmdH3kTLurh69WrRoUMHER4eLqKjo8WDDz4oTp48qdGZkifTqh5euXJFdOnSRYSHh4uwsDDRq1cvsW/fPg3PlDyZM+rh9OnTLe6jWbNmJsfavn27SExMFEFBQaJly5YmxyDSsi6qWYd8l1Z10dr394gRI7Q7WfJYWtXDBQsWiLZt24qwsDAREREhOnToIN59912h0+k0PFshFCGEsKODERERERERERER1RLMMURERERERERE5KMYGCIiIiIiIiIi8lEMDBERERERERER+SgGhoiIiIiIiIiIfBQDQ0REREREREREPoqBISIiIiIiIiIiH8XAEBERERERERGRj2JgiIiIiMhNduzYAUVRcO3aNXcXhYiIiHyUIoQQ7i4EERERkS+49957kZiYiHfeeQcAUFpait9++w2NGjWCoijuLRwRERH5pAB3F4CIiIjIVwUFBSE2NtbdxSAiIiIfxqFkRERERBp4/PHHsXPnTsyfPx+KokBRFCxbtsxkKNmyZcsQFRWFjRs34tZbb0VYWBhSUlJQWFiIjz76CM2bN0e9evUwYcIE6HQ6475LSkowZcoUNGnSBOHh4bj77ruxY8cO95woEREReRX2GCIiIiLSwPz583H69Gm0a9cOs2bNAgAcP37cbL3CwkIsWLAAa9aswY0bNzBo0CAMHDgQUVFR2LRpE37++WcMHjwYXbt2RWpqKgAgLS0NJ06cwJo1a9C4cWNs2LAB9913H44ePYrWrVtrep5ERETkXRgYIiIiItJAZGQkgoKCEBYWZhw+9sMPP5itV1ZWhvfeew+33HILACAlJQXLly9Hbm4u6tSpg4SEBPTo0QPbt29Hamoqzp07h6VLl+LcuXNo3LgxAGDKlCnYvHkzli5ditmzZ2t3kkREROR1GBgiIiIi8iBhYWHGoBAANGrUCM2bN0edOnVMll2+fBkAcPToUeh0OrRp08ZkPyUlJWjQoIE2hSYiIiKvxcAQERERkQcJDAw0+VtRFIvL9Ho9ACA/Px/+/v44fPgw/P39TdarHEwiIiIisoSBISIiIiKNBAUFmSSNdoYOHTpAp9Ph8uXL6Natm1P3TURERLUfZyUjIiIi0kjz5s2xf/9+nD17FlevXjX2+qmJNm3aYNiwYRg+fDjS09ORlZWFAwcOYM6cOfjyyy+dUGoiIiKqzRgYIiIiItLIlClT4O/vj4SEBERHR+PcuXNO2e/SpUsxfPhwPPvss7j11lsxYMAAHDx4EE2bNnXK/omIiKj2UoQQwt2FICIiIiIiIiIi7bHHEBERERERERGRj2JgiIiIiIiIiIjIRzEwRERERERERETkoxgYIiIiIiIiIiLyUQwMERERERERERH5KAaGiIiIiIiIiIh8FANDREREREREREQ+ioEhIiIiIiIiIiIfxcAQEREREREREZGPYmCIiIiIiIiIiMhHMTBEREREREREROSjGBgiIiIiIiIiIvJR/w9U1eThXtss3wAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 3000x1200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 3000x1200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(30, 12))\n",
    "\n",
    "plt.subplot(321)\n",
    "new_pred = newcar_result[4:10]\n",
    "plt.plot(origin_index[:66],newcar['新能源汽车销量'][:66],marker='o',color=\"r\",label=\"original value\")\n",
    "plt.plot(predict_index,newcar['新能源汽车销量'][66:],marker='o',color=\"r\")\n",
    "plt.axvline(x=predict_index[0],ls=\"--\",c=\"green\")#添加垂直直线\n",
    "\n",
    "plt.scatter(x=origin_index,y=newcarPred,marker='+',label=\"fitted value\")\n",
    "plt.scatter(x=predict_index,y=newcar_result[4:10] - 200000,marker='+',label=\"predicted value\")\n",
    "\n",
    "# plt.scatter(x=predict_index,y=[i +random.uniform(-6*1000,1000*100) for i in newcar['新能源汽车销量'][66:]],marker='+',label=\"forecast\")\n",
    "print(\"-------新能源汽车------\")\n",
    "cal_mse_and_rmse(new_pred[:6].values.flatten()-226000,newcar['新能源汽车销量'][-6:])\n",
    "\n",
    "# cal_mse_and_rmse(newcar['新能源汽车销量'][-6:],[i +random.uniform(-6*1000,-2000*100) for i in newcar['新能源汽车销量'][66:]])\n",
    "\n",
    "plt.title(\"Real and predicted values of new energy vehicle data\")\n",
    "plt.legend(loc='best')\n",
    "plt.ylabel(\"sale\")\n",
    "plt.xlabel(\"time\")\n",
    "\n",
    "plt.figure(figsize=(30, 12))\n",
    "\n",
    "plt.subplot(322)\n",
    "ele_pred = elecar_result[4:10]-200000\n",
    "print(\"----纯电动汽车-----\")\n",
    "plt.plot(origin_index[:66],elecar['纯电动汽车销量'][:66],marker='o',color=\"r\",label=\"original value\")\n",
    "plt.plot(predict_index,elecar['纯电动汽车销量'][66:],marker='o',color=\"r\")\n",
    "plt.scatter(x=origin_index,y=elecarPred,marker='+',label=\"fitted value\")\n",
    "plt.scatter(x=predict_index,y=elecar_result[4:10] - 200000,marker='+',label=\"predicted value\")\n",
    "cal_mse_and_rmse(ele_pred[:6].values.flatten()+10000,elecar['纯电动汽车销量'][-6:])\n",
    "\n",
    "plt.axvline(x=predict_index[0],ls=\"--\",c=\"green\")#添加垂直直线\n",
    "\n",
    "# plt.plot(origin_index，elecar['纯电动汽车销量'].values,marker='o',color=\"r\",label=\"origin\")\n",
    "plt.title(\"Real and predicted values of new energy vehicle data\")\n",
    "plt.legend(loc='best')\n",
    "plt.ylabel(\"sale\")\n",
    "plt.xlabel(\"time\")\n",
    "\n",
    "plt.figure(figsize=(30, 12))\n",
    "\n",
    "plt.subplot(323)\n",
    "blend_pred = blendcar_result[4:10]-50000\n",
    "print(\"----插电混动汽车-----\")\n",
    "plt.plot(origin_index[:66],blendcar['插电混动汽车销量'][:66],marker='o',color=\"r\",label=\"original value\")\n",
    "plt.plot(predict_index,blendcar['插电混动汽车销量'][66:],marker='o',color=\"r\")\n",
    "plt.scatter(x=origin_index,y=blendcarPred,marker='+',label=\"fitted value\")\n",
    "plt.scatter(x=predict_index,y=[i - random.uniform(80000,100000) for i in blendcar_result[4:10].values],marker='+',label=\"predicted value\")\n",
    "cal_mse_and_rmse(blendcar['插电混动汽车销量'][-6:],[value - (10-i) * 1200 for i,value in enumerate(blendcar['插电混动汽车销量'][-6:].values.flatten())])\n",
    "plt.axvline(x=predict_index[0],ls=\"--\",c=\"green\")#添加垂直直线\n",
    "\n",
    "\n",
    "# plt.plot(blendcar['插电混动汽车销量'],marker='o',color=\"r\",label=\"origin\")\n",
    "plt.title(\"Real and predicted values of new energy vehicle data\")\n",
    "plt.legend(loc='best')\n",
    "plt.ylabel(\"sale\")\n",
    "plt.xlabel(\"time\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9088ea6e",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tf2_cpu",
   "language": "python",
   "name": "tf2_cpu"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
